at_commands/generated/
translate.rs

1// Copyright 2021 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5// This file is generated code.  Please do not edit it; instead edit the AT
6// command definitions used to generate it.
7
8use crate::lowlevel;
9use crate::highlevel;
10use crate::serde::DeserializeErrorCause;
11use crate::translate_util::*;
12use num_traits::FromPrimitive;
13
14pub fn raise_command(lowlevel: &lowlevel::Command) -> Result<highlevel::Command, DeserializeErrorCause> {
15    match lowlevel {
16        lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
17            name == "TESTEX"
18            && delimiter == &None
19        => {
20            Ok(highlevel::Command::Testex {
21            })
22        },
23        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
24            name == "TESTEXEXT"
25            && delimiter == &None
26        => {
27            Ok(highlevel::Command::Testexext {
28            })
29        },
30        lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
31            name == "TESTNEX"
32            && delimiter == &None
33        => {
34            Ok(highlevel::Command::TestCommand {
35            })
36        },
37        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
38            name == "TESTEXEXTFI"
39            && delimiter == &Some(String::from("="))
40            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
41        => {
42            let arg_vec = extract_vec_from_args(&arguments)?;
43            let field_option = arg_vec.get(0);
44            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
45            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
46            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
47            Ok(highlevel::Command::Testexextfi {
48                field,
49            })
50        },
51        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
52            name == "TESTEXEXTFIC"
53            && delimiter == &Some(String::from("="))
54            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
55        => {
56            let arg_vec = extract_vec_from_args(&arguments)?;
57            let field_option = arg_vec.get(0);
58            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
59            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
60            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
61            Ok(highlevel::Command::Testexextfic {
62                field,
63            })
64        },
65        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
66            name == "TESTNSD"
67            && delimiter == &Some(String::from(">"))
68            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
69        => {
70            let arg_vec = extract_vec_from_args(&arguments)?;
71            let field_option = arg_vec.get(0);
72            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
73            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
74            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
75            Ok(highlevel::Command::Testnsd {
76                field,
77            })
78        },
79        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
80            name == "TESTNST"
81            && delimiter == &Some(String::from("="))
82            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
83        => {
84            let arg_vec = extract_vec_from_args(&arguments)?;
85            let field_option = arg_vec.get(0);
86            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
87            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
88            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
89            Ok(highlevel::Command::Testnst {
90                field,
91            })
92        },
93        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
94            name == "TESTNSDNST"
95            && delimiter == &Some(String::from(">"))
96            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
97        => {
98            let arg_vec = extract_vec_from_args(&arguments)?;
99            let field_option = arg_vec.get(0);
100            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
101            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
102            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
103            Ok(highlevel::Command::Testnsdnst {
104                field,
105            })
106        },
107        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
108            name == "TESTNOD"
109            && delimiter == &None
110            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
111        => {
112            let arg_vec = extract_vec_from_args(&arguments)?;
113            let field_option = arg_vec.get(0);
114            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
115            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
116            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
117            Ok(highlevel::Command::Testnod {
118                field,
119            })
120        },
121        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
122            name == "TESTEXEXTFS"
123            && delimiter == &Some(String::from("="))
124            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
125        => {
126            let arg_vec = extract_vec_from_args(&arguments)?;
127            let field_option = arg_vec.get(0);
128            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
129            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
130            let field = field_option_unwrapped_primitive.clone();
131            Ok(highlevel::Command::Testexextfs {
132                field,
133            })
134        },
135        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
136            name == "TESTEXEXTFSI"
137            && delimiter == &Some(String::from("="))
138            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
139        => {
140            let arg_vec = extract_vec_from_args(&arguments)?;
141            let field1_option = arg_vec.get(0);
142            let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
143            let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
144            let field1 = field1_option_unwrapped_primitive.clone();
145            let field2_option = arg_vec.get(1);
146            let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
147            let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
148            let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
149            Ok(highlevel::Command::Testexextfsi {
150                field1,
151                field2,
152            })
153        },
154        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
155            name == "TESTEXEXTFSIC"
156            && delimiter == &Some(String::from("="))
157            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
158        => {
159            let arg_vec = extract_vec_from_args(&arguments)?;
160            let field1_option = arg_vec.get(0);
161            let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
162            let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
163            let field1 = field1_option_unwrapped_primitive.clone();
164            let field2_option = arg_vec.get(1);
165            let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
166            let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
167            let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
168            Ok(highlevel::Command::Testexextfsic {
169                field1,
170                field2,
171            })
172        },
173        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
174            name == "TESTIO"
175            && delimiter == &Some(String::from("="))
176            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
177        => {
178            let arg_vec = extract_vec_from_args(&arguments)?;
179            let field1_option = arg_vec.get(0);
180            let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
181            let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
182            let field1 = extract_int_from_primitive(field1_option_unwrapped_primitive, &arguments)?;
183            let field2_option = arg_vec.get(1);
184            let field2 = match field2_option {
185                Some(field2_option_unwrapped) if !field2_option_unwrapped.is_empty() => {
186                    let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
187                    let field2_unwrapped = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
188                    Some(field2_unwrapped)
189                }
190                _ => None,
191            };
192            Ok(highlevel::Command::Testio {
193                field1,
194                field2,
195            })
196        },
197        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
198            name == "TESTL"
199            && delimiter == &Some(String::from("="))
200            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
201        => {
202            let arg_vec = extract_vec_from_args(&arguments)?;
203            let mut field = Vec::new();
204            for field_element_raw in arg_vec[0..].into_iter() {
205                let field_element_option = if field_element_raw.is_empty() { None } else { Some(field_element_raw) };
206                let field_element_option_unwrapped = field_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
207                let field_element_option_unwrapped_primitive = extract_primitive_from_field(field_element_option_unwrapped, &arguments)?;
208                let field_element = extract_int_from_primitive(field_element_option_unwrapped_primitive, &arguments)?;
209                field.push(field_element);
210            }
211            Ok(highlevel::Command::Testl {
212                field,
213            })
214        },
215        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
216            name == "TESTOL"
217            && delimiter == &Some(String::from("="))
218            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
219        => {
220            let arg_vec = extract_vec_from_args(&arguments)?;
221            let mut field = Vec::new();
222            for field_element_raw in arg_vec[0..].into_iter() {
223                let field_element_option = if field_element_raw.is_empty() { None } else { Some(field_element_raw) };
224                let field_element = match field_element_option {
225                    Some(field_element_option_unwrapped) if !field_element_option_unwrapped.is_empty() => {
226                        let field_element_option_unwrapped_primitive = extract_primitive_from_field(field_element_option_unwrapped, &arguments)?;
227                        let field_element_unwrapped = extract_int_from_primitive(field_element_option_unwrapped_primitive, &arguments)?;
228                        Some(field_element_unwrapped)
229                    }
230                    _ => None,
231                };
232                field.push(field_element);
233            }
234            Ok(highlevel::Command::Testol {
235                field,
236            })
237        },
238        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
239            name == "TESTM"
240            && delimiter == &Some(String::from("="))
241            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
242        => {
243            let arg_vec = extract_vec_from_args(&arguments)?;
244            let mut field = std::collections::HashMap::new();
245            for field_element in arg_vec[0..].into_iter() {
246                let field_element_primitive = extract_key_from_field(field_element, &arguments)?;
247                let field_key = extract_int_from_primitive(field_element_primitive, &arguments)?;
248                let field_element_primitive = extract_value_from_field(field_element, &arguments)?;
249                let field_value = field_element_primitive.clone();
250                let _ = field.insert(field_key, field_value);
251            }   
252            Ok(highlevel::Command::Testm {
253                field,
254            })
255        },
256        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
257            name == "TESTP"
258            && delimiter == &Some(String::from("="))
259            &&  matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
260        => {
261            let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
262            let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
263            let field_option = arg_vec.get(0);
264            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
265            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
266            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
267            Ok(highlevel::Command::Testp {
268                field,
269            })
270        },
271        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
272            name == "TESTPP"
273            && delimiter == &Some(String::from("="))
274            &&  matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
275        => {
276            let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
277            let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
278            let field1_option = arg_vec.get(0);
279            let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
280            let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
281            let field1 = extract_int_from_primitive(field1_option_unwrapped_primitive, &arguments)?;
282            let arg_vec = arg_vec_vec.get(1).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
283            let field2_option = arg_vec.get(0);
284            let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
285            let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
286            let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
287            let field3_option = arg_vec.get(1);
288            let field3_option_unwrapped = field3_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
289            let field3_option_unwrapped_primitive = extract_primitive_from_field(field3_option_unwrapped, &arguments)?;
290            let field3 = field3_option_unwrapped_primitive.clone();
291            Ok(highlevel::Command::Testpp {
292                field1,
293                field2,
294                field3,
295            })
296        },
297        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
298            name == "TESTPMPIL"
299            && delimiter == &Some(String::from("="))
300            &&  matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
301        => {
302            let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
303            let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
304            let mut field1 = std::collections::HashMap::new();
305            for field1_element in arg_vec[0..].into_iter() {
306                let field1_element_primitive = extract_key_from_field(field1_element, &arguments)?;
307                let field1_key = extract_int_from_primitive(field1_element_primitive, &arguments)?;
308                let field1_element_primitive = extract_value_from_field(field1_element, &arguments)?;
309                let field1_value = field1_element_primitive.clone();
310                let _ = field1.insert(field1_key, field1_value);
311            }   
312            let arg_vec = arg_vec_vec.get(1).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
313            let field2_option = arg_vec.get(0);
314            let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
315            let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
316            let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
317            let mut field3 = Vec::new();
318            for field3_element_raw in arg_vec[1..].into_iter() {
319                let field3_element_option = if field3_element_raw.is_empty() { None } else { Some(field3_element_raw) };
320                let field3_element_option_unwrapped = field3_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
321                let field3_element_option_unwrapped_primitive = extract_primitive_from_field(field3_element_option_unwrapped, &arguments)?;
322                let field3_element = extract_int_from_primitive(field3_element_option_unwrapped_primitive, &arguments)?;
323                field3.push(field3_element);
324            }
325            Ok(highlevel::Command::Testpmpil {
326                field1,
327                field2,
328                field3,
329            })
330        },
331        lowlevel::Command::Read { name, is_extension: false, ..} if
332            name == "TESTR"
333        => {
334            Ok(highlevel::Command::TestrRead {})
335        },
336        lowlevel::Command::Read { name, is_extension: true, ..} if
337            name == "TESTREX"
338        => {
339            Ok(highlevel::Command::TestrexRead {})
340        },
341        lowlevel::Command::Test { name, is_extension: false, ..} if
342            name == "TESTT"
343        => {
344            Ok(highlevel::Command::TesttTest {})
345        },
346        lowlevel::Command::Test { name, is_extension: true, ..} if
347            name == "TESTTEX"
348        => {
349            Ok(highlevel::Command::TesttexTest {})
350        },
351        lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
352            name == "TESTENUM"
353            && delimiter == &Some(String::from("="))
354            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
355        => {
356            let arg_vec = extract_vec_from_args(&arguments)?;
357            let field_option = arg_vec.get(0);
358            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
359            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
360            let field_option_unwrapped_int = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
361            let field = super::types::TestOneVariantComma::from_i64(field_option_unwrapped_int).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
362            Ok(highlevel::Command::Testenum {
363                field,
364            })
365        },
366        lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
367            name == "TESTBOOL"
368            && delimiter == &Some(String::from("="))
369            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
370        => {
371            let arg_vec = extract_vec_from_args(&arguments)?;
372            let field_option = arg_vec.get(0);
373            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
374            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
375            let field_option_unwrapped_int = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
376            let field = field_option_unwrapped_int != 0;
377            Ok(highlevel::Command::Testbool {
378                field,
379            })
380        },
381        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
382            name == "TESTOTHERFILE"
383            && delimiter == &None
384        => {
385            Ok(highlevel::Command::Testotherfile {
386            })
387        },
388        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
389            name == "BRSF"
390            && delimiter == &Some(String::from("="))
391            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
392        => {
393            let arg_vec = extract_vec_from_args(&arguments)?;
394            let features_option = arg_vec.get(0);
395            let features_option_unwrapped = features_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
396            let features_option_unwrapped_primitive = extract_primitive_from_field(features_option_unwrapped, &arguments)?;
397            let features = extract_int_from_primitive(features_option_unwrapped_primitive, &arguments)?;
398            Ok(highlevel::Command::Brsf {
399                features,
400            })
401        },
402        lowlevel::Command::Test { name, is_extension: true, ..} if
403            name == "CIND"
404        => {
405            Ok(highlevel::Command::CindTest {})
406        },
407        lowlevel::Command::Read { name, is_extension: true, ..} if
408            name == "CIND"
409        => {
410            Ok(highlevel::Command::CindRead {})
411        },
412        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
413            name == "CLCC"
414            && delimiter == &None
415        => {
416            Ok(highlevel::Command::Clcc {
417            })
418        },
419        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
420            name == "BCC"
421            && delimiter == &None
422        => {
423            Ok(highlevel::Command::Bcc {
424            })
425        },
426        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
427            name == "BCS"
428            && delimiter == &Some(String::from("="))
429            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
430        => {
431            let arg_vec = extract_vec_from_args(&arguments)?;
432            let codec_option = arg_vec.get(0);
433            let codec_option_unwrapped = codec_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
434            let codec_option_unwrapped_primitive = extract_primitive_from_field(codec_option_unwrapped, &arguments)?;
435            let codec = extract_int_from_primitive(codec_option_unwrapped_primitive, &arguments)?;
436            Ok(highlevel::Command::Bcs {
437                codec,
438            })
439        },
440        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
441            name == "BAC"
442            && delimiter == &Some(String::from("="))
443            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
444        => {
445            let arg_vec = extract_vec_from_args(&arguments)?;
446            let mut codecs = Vec::new();
447            for codecs_element_raw in arg_vec[0..].into_iter() {
448                let codecs_element_option = if codecs_element_raw.is_empty() { None } else { Some(codecs_element_raw) };
449                let codecs_element_option_unwrapped = codecs_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
450                let codecs_element_option_unwrapped_primitive = extract_primitive_from_field(codecs_element_option_unwrapped, &arguments)?;
451                let codecs_element = extract_int_from_primitive(codecs_element_option_unwrapped_primitive, &arguments)?;
452                codecs.push(codecs_element);
453            }
454            Ok(highlevel::Command::Bac {
455                codecs,
456            })
457        },
458        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
459            name == "BIND"
460            && delimiter == &Some(String::from("="))
461            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
462        => {
463            let arg_vec = extract_vec_from_args(&arguments)?;
464            let mut indicators = Vec::new();
465            for indicators_element_raw in arg_vec[0..].into_iter() {
466                let indicators_element_option = if indicators_element_raw.is_empty() { None } else { Some(indicators_element_raw) };
467                let indicators_element_option_unwrapped = indicators_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
468                let indicators_element_option_unwrapped_primitive = extract_primitive_from_field(indicators_element_option_unwrapped, &arguments)?;
469                let indicators_element = extract_int_from_primitive(indicators_element_option_unwrapped_primitive, &arguments)?;
470                indicators.push(indicators_element);
471            }
472            Ok(highlevel::Command::Bind {
473                indicators,
474            })
475        },
476        lowlevel::Command::Test { name, is_extension: true, ..} if
477            name == "BIND"
478        => {
479            Ok(highlevel::Command::BindTest {})
480        },
481        lowlevel::Command::Read { name, is_extension: true, ..} if
482            name == "BIND"
483        => {
484            Ok(highlevel::Command::BindRead {})
485        },
486        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
487            name == "BIEV"
488            && delimiter == &Some(String::from("="))
489            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
490        => {
491            let arg_vec = extract_vec_from_args(&arguments)?;
492            let anum_option = arg_vec.get(0);
493            let anum_option_unwrapped = anum_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
494            let anum_option_unwrapped_primitive = extract_primitive_from_field(anum_option_unwrapped, &arguments)?;
495            let anum_option_unwrapped_int = extract_int_from_primitive(anum_option_unwrapped_primitive, &arguments)?;
496            let anum = super::types::BluetoothHFIndicator::from_i64(anum_option_unwrapped_int).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
497            let value_option = arg_vec.get(1);
498            let value_option_unwrapped = value_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
499            let value_option_unwrapped_primitive = extract_primitive_from_field(value_option_unwrapped, &arguments)?;
500            let value = extract_int_from_primitive(value_option_unwrapped_primitive, &arguments)?;
501            Ok(highlevel::Command::Biev {
502                anum,
503                value,
504            })
505        },
506        lowlevel::Command::Test { name, is_extension: true, ..} if
507            name == "CHLD"
508        => {
509            Ok(highlevel::Command::ChldTest {})
510        },
511        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
512            name == "CMER"
513            && delimiter == &Some(String::from("="))
514            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
515        => {
516            let arg_vec = extract_vec_from_args(&arguments)?;
517            let mode_option = arg_vec.get(0);
518            let mode_option_unwrapped = mode_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
519            let mode_option_unwrapped_primitive = extract_primitive_from_field(mode_option_unwrapped, &arguments)?;
520            let mode = extract_int_from_primitive(mode_option_unwrapped_primitive, &arguments)?;
521            let keyp_option = arg_vec.get(1);
522            let keyp_option_unwrapped = keyp_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
523            let keyp_option_unwrapped_primitive = extract_primitive_from_field(keyp_option_unwrapped, &arguments)?;
524            let keyp = extract_int_from_primitive(keyp_option_unwrapped_primitive, &arguments)?;
525            let disp_option = arg_vec.get(2);
526            let disp_option_unwrapped = disp_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
527            let disp_option_unwrapped_primitive = extract_primitive_from_field(disp_option_unwrapped, &arguments)?;
528            let disp = extract_int_from_primitive(disp_option_unwrapped_primitive, &arguments)?;
529            let ind_option = arg_vec.get(3);
530            let ind_option_unwrapped = ind_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
531            let ind_option_unwrapped_primitive = extract_primitive_from_field(ind_option_unwrapped, &arguments)?;
532            let ind = extract_int_from_primitive(ind_option_unwrapped_primitive, &arguments)?;
533            Ok(highlevel::Command::Cmer {
534                mode,
535                keyp,
536                disp,
537                ind,
538            })
539        },
540        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
541            name == "NREC"
542            && delimiter == &Some(String::from("="))
543            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
544        => {
545            let arg_vec = extract_vec_from_args(&arguments)?;
546            let nrec_option = arg_vec.get(0);
547            let nrec_option_unwrapped = nrec_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
548            let nrec_option_unwrapped_primitive = extract_primitive_from_field(nrec_option_unwrapped, &arguments)?;
549            let nrec_option_unwrapped_int = extract_int_from_primitive(nrec_option_unwrapped_primitive, &arguments)?;
550            let nrec = nrec_option_unwrapped_int != 0;
551            Ok(highlevel::Command::Nrec {
552                nrec,
553            })
554        },
555        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
556            name == "COPS"
557            && delimiter == &Some(String::from("="))
558            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
559        => {
560            let arg_vec = extract_vec_from_args(&arguments)?;
561            let three_option = arg_vec.get(0);
562            let three_option_unwrapped = three_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
563            let three_option_unwrapped_primitive = extract_primitive_from_field(three_option_unwrapped, &arguments)?;
564            let three = extract_int_from_primitive(three_option_unwrapped_primitive, &arguments)?;
565            let format_option = arg_vec.get(1);
566            let format_option_unwrapped = format_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
567            let format_option_unwrapped_primitive = extract_primitive_from_field(format_option_unwrapped, &arguments)?;
568            let format_option_unwrapped_int = extract_int_from_primitive(format_option_unwrapped_primitive, &arguments)?;
569            let format = super::types::NetworkOperatorNameFormat::from_i64(format_option_unwrapped_int).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
570            Ok(highlevel::Command::Cops {
571                three,
572                format,
573            })
574        },
575        lowlevel::Command::Read { name, is_extension: true, ..} if
576            name == "COPS"
577        => {
578            Ok(highlevel::Command::CopsRead {})
579        },
580        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
581            name == "CMEE"
582            && delimiter == &Some(String::from("="))
583            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
584        => {
585            let arg_vec = extract_vec_from_args(&arguments)?;
586            let enable_option = arg_vec.get(0);
587            let enable_option_unwrapped = enable_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
588            let enable_option_unwrapped_primitive = extract_primitive_from_field(enable_option_unwrapped, &arguments)?;
589            let enable_option_unwrapped_int = extract_int_from_primitive(enable_option_unwrapped_primitive, &arguments)?;
590            let enable = enable_option_unwrapped_int != 0;
591            Ok(highlevel::Command::Cmee {
592                enable,
593            })
594        },
595        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
596            name == "CCWA"
597            && delimiter == &Some(String::from("="))
598            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
599        => {
600            let arg_vec = extract_vec_from_args(&arguments)?;
601            let enable_option = arg_vec.get(0);
602            let enable_option_unwrapped = enable_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
603            let enable_option_unwrapped_primitive = extract_primitive_from_field(enable_option_unwrapped, &arguments)?;
604            let enable_option_unwrapped_int = extract_int_from_primitive(enable_option_unwrapped_primitive, &arguments)?;
605            let enable = enable_option_unwrapped_int != 0;
606            Ok(highlevel::Command::Ccwa {
607                enable,
608            })
609        },
610        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
611            name == "CLIP"
612            && delimiter == &Some(String::from("="))
613            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
614        => {
615            let arg_vec = extract_vec_from_args(&arguments)?;
616            let enable_option = arg_vec.get(0);
617            let enable_option_unwrapped = enable_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
618            let enable_option_unwrapped_primitive = extract_primitive_from_field(enable_option_unwrapped, &arguments)?;
619            let enable_option_unwrapped_int = extract_int_from_primitive(enable_option_unwrapped_primitive, &arguments)?;
620            let enable = enable_option_unwrapped_int != 0;
621            Ok(highlevel::Command::Clip {
622                enable,
623            })
624        },
625        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
626            name == "CNUM"
627            && delimiter == &None
628        => {
629            Ok(highlevel::Command::Cnum {
630            })
631        },
632        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
633            name == "VTS"
634            && delimiter == &Some(String::from("="))
635            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
636        => {
637            let arg_vec = extract_vec_from_args(&arguments)?;
638            let code_option = arg_vec.get(0);
639            let code_option_unwrapped = code_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
640            let code_option_unwrapped_primitive = extract_primitive_from_field(code_option_unwrapped, &arguments)?;
641            let code = code_option_unwrapped_primitive.clone();
642            Ok(highlevel::Command::Vts {
643                code,
644            })
645        },
646        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
647            name == "VGS"
648            && delimiter == &Some(String::from("="))
649            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
650        => {
651            let arg_vec = extract_vec_from_args(&arguments)?;
652            let level_option = arg_vec.get(0);
653            let level_option_unwrapped = level_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
654            let level_option_unwrapped_primitive = extract_primitive_from_field(level_option_unwrapped, &arguments)?;
655            let level = extract_int_from_primitive(level_option_unwrapped_primitive, &arguments)?;
656            Ok(highlevel::Command::Vgs {
657                level,
658            })
659        },
660        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
661            name == "VGM"
662            && delimiter == &Some(String::from("="))
663            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
664        => {
665            let arg_vec = extract_vec_from_args(&arguments)?;
666            let level_option = arg_vec.get(0);
667            let level_option_unwrapped = level_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
668            let level_option_unwrapped_primitive = extract_primitive_from_field(level_option_unwrapped, &arguments)?;
669            let level = extract_int_from_primitive(level_option_unwrapped_primitive, &arguments)?;
670            Ok(highlevel::Command::Vgm {
671                level,
672            })
673        },
674        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
675            name == "BIA"
676            && delimiter == &Some(String::from("="))
677            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
678        => {
679            let arg_vec = extract_vec_from_args(&arguments)?;
680            let mut indrep = Vec::new();
681            for indrep_element_raw in arg_vec[0..].into_iter() {
682                let indrep_element_option = if indrep_element_raw.is_empty() { None } else { Some(indrep_element_raw) };
683                let indrep_element = match indrep_element_option {
684                    Some(indrep_element_option_unwrapped) if !indrep_element_option_unwrapped.is_empty() => {
685                        let indrep_element_option_unwrapped_primitive = extract_primitive_from_field(indrep_element_option_unwrapped, &arguments)?;
686                        let indrep_element_option_unwrapped_int = extract_int_from_primitive(indrep_element_option_unwrapped_primitive, &arguments)?;
687                        let indrep_element_unwrapped = indrep_element_option_unwrapped_int != 0;
688                        Some(indrep_element_unwrapped)
689                    }
690                    _ => None,
691                };
692                indrep.push(indrep_element);
693            }
694            Ok(highlevel::Command::Bia {
695                indrep,
696            })
697        },
698        lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
699            name == "A"
700            && delimiter == &None
701        => {
702            Ok(highlevel::Command::Answer {
703            })
704        },
705        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
706            name == "CHUP"
707            && delimiter == &None
708        => {
709            Ok(highlevel::Command::Chup {
710            })
711        },
712        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
713            name == "CHLD"
714            && delimiter == &Some(String::from("="))
715            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
716        => {
717            let arg_vec = extract_vec_from_args(&arguments)?;
718            let command_option = arg_vec.get(0);
719            let command_option_unwrapped = command_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
720            let command_option_unwrapped_primitive = extract_primitive_from_field(command_option_unwrapped, &arguments)?;
721            let command = command_option_unwrapped_primitive.clone();
722            Ok(highlevel::Command::Chld {
723                command,
724            })
725        },
726        lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
727            name == "D"
728            && delimiter == &None
729            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
730        => {
731            let arg_vec = extract_vec_from_args(&arguments)?;
732            let number_option = arg_vec.get(0);
733            let number_option_unwrapped = number_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
734            let number_option_unwrapped_primitive = extract_primitive_from_field(number_option_unwrapped, &arguments)?;
735            let number = number_option_unwrapped_primitive.clone();
736            Ok(highlevel::Command::AtdNumber {
737                number,
738            })
739        },
740        lowlevel::Command::Execute { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
741            name == "D"
742            && delimiter == &Some(String::from(">"))
743            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
744        => {
745            let arg_vec = extract_vec_from_args(&arguments)?;
746            let location_option = arg_vec.get(0);
747            let location_option_unwrapped = location_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
748            let location_option_unwrapped_primitive = extract_primitive_from_field(location_option_unwrapped, &arguments)?;
749            let location = location_option_unwrapped_primitive.clone();
750            Ok(highlevel::Command::AtdMemory {
751                location,
752            })
753        },
754        lowlevel::Command::Execute { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
755            name == "BLDN"
756            && delimiter == &None
757        => {
758            Ok(highlevel::Command::Bldn {
759            })
760        },
761        _ => Err(DeserializeErrorCause::UnknownCommand(lowlevel.clone())),
762    }
763}
764
765// Clients are responsible for ensuring this is only called with lowlevel::Result::Success.
766pub fn raise_success(lowlevel: &lowlevel::Response) -> Result<highlevel::Success, DeserializeErrorCause> {
767    match lowlevel {
768        lowlevel::Response::Success { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
769            name == "TEST"
770            && delimiter == &Some(String::from(":"))
771        => {
772            Ok(highlevel::Success::Test {
773            })
774        },
775        lowlevel::Response::Success { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
776            name == "TESTNOD"
777            && delimiter == &None
778        => {
779            Ok(highlevel::Success::Testnod {
780            })
781        },
782        lowlevel::Response::Success { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
783            name == "TESTN"
784            && delimiter == &Some(String::from(":"))
785        => {
786            Ok(highlevel::Success::TestResponse {
787            })
788        },
789        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
790            name == "TESTEXT"
791            && delimiter == &Some(String::from(":"))
792        => {
793            Ok(highlevel::Success::Testext {
794            })
795        },
796        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
797            name == "TESTEXTNOD"
798            && delimiter == &None
799        => {
800            Ok(highlevel::Success::Testextnod {
801            })
802        },
803        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
804            name == "TESTI"
805            && delimiter == &Some(String::from(":"))
806            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
807        => {
808            let arg_vec = extract_vec_from_args(&arguments)?;
809            let field_option = arg_vec.get(0);
810            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
811            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
812            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
813            Ok(highlevel::Success::Testi {
814                field,
815            })
816        },
817        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
818            name == "TESTINOD"
819            && delimiter == &None
820            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
821        => {
822            let arg_vec = extract_vec_from_args(&arguments)?;
823            let field_option = arg_vec.get(0);
824            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
825            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
826            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
827            Ok(highlevel::Success::Testinod {
828                field,
829            })
830        },
831        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
832            name == "TESTIC"
833            && delimiter == &Some(String::from(":"))
834            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
835        => {
836            let arg_vec = extract_vec_from_args(&arguments)?;
837            let field_option = arg_vec.get(0);
838            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
839            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
840            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
841            Ok(highlevel::Success::Testic {
842                field,
843            })
844        },
845        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
846            name == "TESTS"
847            && delimiter == &Some(String::from(":"))
848            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
849        => {
850            let arg_vec = extract_vec_from_args(&arguments)?;
851            let field_option = arg_vec.get(0);
852            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
853            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
854            let field = field_option_unwrapped_primitive.clone();
855            Ok(highlevel::Success::Tests {
856                field,
857            })
858        },
859        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
860            name == "TESTSI"
861            && delimiter == &Some(String::from(":"))
862            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
863        => {
864            let arg_vec = extract_vec_from_args(&arguments)?;
865            let field1_option = arg_vec.get(0);
866            let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
867            let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
868            let field1 = field1_option_unwrapped_primitive.clone();
869            let field2_option = arg_vec.get(1);
870            let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
871            let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
872            let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
873            Ok(highlevel::Success::Testsi {
874                field1,
875                field2,
876            })
877        },
878        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
879            name == "TESTSIC"
880            && delimiter == &Some(String::from(":"))
881            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
882        => {
883            let arg_vec = extract_vec_from_args(&arguments)?;
884            let field1_option = arg_vec.get(0);
885            let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
886            let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
887            let field1 = field1_option_unwrapped_primitive.clone();
888            let field2_option = arg_vec.get(1);
889            let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
890            let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
891            let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
892            Ok(highlevel::Success::Testsic {
893                field1,
894                field2,
895            })
896        },
897        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
898            name == "TESTIO"
899            && delimiter == &Some(String::from(":"))
900            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
901        => {
902            let arg_vec = extract_vec_from_args(&arguments)?;
903            let field1_option = arg_vec.get(0);
904            let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
905            let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
906            let field1 = extract_int_from_primitive(field1_option_unwrapped_primitive, &arguments)?;
907            let field2_option = arg_vec.get(1);
908            let field2 = match field2_option {
909                Some(field2_option_unwrapped) if !field2_option_unwrapped.is_empty() => {
910                    let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
911                    let field2_unwrapped = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
912                    Some(field2_unwrapped)
913                }
914                _ => None,
915            };
916            Ok(highlevel::Success::Testio {
917                field1,
918                field2,
919            })
920        },
921        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
922            name == "TESTL"
923            && delimiter == &Some(String::from(":"))
924            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
925        => {
926            let arg_vec = extract_vec_from_args(&arguments)?;
927            let mut field = Vec::new();
928            for field_element_raw in arg_vec[0..].into_iter() {
929                let field_element_option = if field_element_raw.is_empty() { None } else { Some(field_element_raw) };
930                let field_element_option_unwrapped = field_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
931                let field_element_option_unwrapped_primitive = extract_primitive_from_field(field_element_option_unwrapped, &arguments)?;
932                let field_element = extract_int_from_primitive(field_element_option_unwrapped_primitive, &arguments)?;
933                field.push(field_element);
934            }
935            Ok(highlevel::Success::Testl {
936                field,
937            })
938        },
939        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
940            name == "TESTOL"
941            && delimiter == &Some(String::from(":"))
942            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
943        => {
944            let arg_vec = extract_vec_from_args(&arguments)?;
945            let mut field = Vec::new();
946            for field_element_raw in arg_vec[0..].into_iter() {
947                let field_element_option = if field_element_raw.is_empty() { None } else { Some(field_element_raw) };
948                let field_element = match field_element_option {
949                    Some(field_element_option_unwrapped) if !field_element_option_unwrapped.is_empty() => {
950                        let field_element_option_unwrapped_primitive = extract_primitive_from_field(field_element_option_unwrapped, &arguments)?;
951                        let field_element_unwrapped = extract_int_from_primitive(field_element_option_unwrapped_primitive, &arguments)?;
952                        Some(field_element_unwrapped)
953                    }
954                    _ => None,
955                };
956                field.push(field_element);
957            }
958            Ok(highlevel::Success::Testol {
959                field,
960            })
961        },
962        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
963            name == "TESTM"
964            && delimiter == &Some(String::from(":"))
965            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
966        => {
967            let arg_vec = extract_vec_from_args(&arguments)?;
968            let mut field = std::collections::HashMap::new();
969            for field_element in arg_vec[0..].into_iter() {
970                let field_element_primitive = extract_key_from_field(field_element, &arguments)?;
971                let field_key = extract_int_from_primitive(field_element_primitive, &arguments)?;
972                let field_element_primitive = extract_value_from_field(field_element, &arguments)?;
973                let field_value = field_element_primitive.clone();
974                let _ = field.insert(field_key, field_value);
975            }   
976            Ok(highlevel::Success::Testm {
977                field,
978            })
979        },
980        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
981            name == "TESTP"
982            && delimiter == &Some(String::from(":"))
983            &&  matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
984        => {
985            let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
986            let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
987            let field_option = arg_vec.get(0);
988            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
989            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
990            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
991            Ok(highlevel::Success::Testp {
992                field,
993            })
994        },
995        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
996            name == "TESTPP"
997            && delimiter == &Some(String::from(":"))
998            &&  matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
999        => {
1000            let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
1001            let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1002            let field1_option = arg_vec.get(0);
1003            let field1_option_unwrapped = field1_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1004            let field1_option_unwrapped_primitive = extract_primitive_from_field(field1_option_unwrapped, &arguments)?;
1005            let field1 = extract_int_from_primitive(field1_option_unwrapped_primitive, &arguments)?;
1006            let arg_vec = arg_vec_vec.get(1).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1007            let field2_option = arg_vec.get(0);
1008            let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1009            let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
1010            let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
1011            let field3_option = arg_vec.get(1);
1012            let field3_option_unwrapped = field3_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1013            let field3_option_unwrapped_primitive = extract_primitive_from_field(field3_option_unwrapped, &arguments)?;
1014            let field3 = field3_option_unwrapped_primitive.clone();
1015            Ok(highlevel::Success::Testpp {
1016                field1,
1017                field2,
1018                field3,
1019            })
1020        },
1021        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1022            name == "TESTPMPIL"
1023            && delimiter == &Some(String::from(":"))
1024            &&  matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
1025        => {
1026            let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
1027            let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1028            let mut field1 = std::collections::HashMap::new();
1029            for field1_element in arg_vec[0..].into_iter() {
1030                let field1_element_primitive = extract_key_from_field(field1_element, &arguments)?;
1031                let field1_key = extract_int_from_primitive(field1_element_primitive, &arguments)?;
1032                let field1_element_primitive = extract_value_from_field(field1_element, &arguments)?;
1033                let field1_value = field1_element_primitive.clone();
1034                let _ = field1.insert(field1_key, field1_value);
1035            }   
1036            let arg_vec = arg_vec_vec.get(1).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1037            let field2_option = arg_vec.get(0);
1038            let field2_option_unwrapped = field2_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1039            let field2_option_unwrapped_primitive = extract_primitive_from_field(field2_option_unwrapped, &arguments)?;
1040            let field2 = extract_int_from_primitive(field2_option_unwrapped_primitive, &arguments)?;
1041            let mut field3 = Vec::new();
1042            for field3_element_raw in arg_vec[1..].into_iter() {
1043                let field3_element_option = if field3_element_raw.is_empty() { None } else { Some(field3_element_raw) };
1044                let field3_element_option_unwrapped = field3_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1045                let field3_element_option_unwrapped_primitive = extract_primitive_from_field(field3_element_option_unwrapped, &arguments)?;
1046                let field3_element = extract_int_from_primitive(field3_element_option_unwrapped_primitive, &arguments)?;
1047                field3.push(field3_element);
1048            }
1049            Ok(highlevel::Success::Testpmpil {
1050                field1,
1051                field2,
1052                field3,
1053            })
1054        },
1055        lowlevel::Response::Success { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1056            name == "SAME"
1057            && delimiter == &Some(String::from(":"))
1058            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1059        => {
1060            let arg_vec = extract_vec_from_args(&arguments)?;
1061            let field_option = arg_vec.get(0);
1062            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1063            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
1064            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
1065            Ok(highlevel::Success::SameOne {
1066                field,
1067            })
1068        },
1069        lowlevel::Response::Success { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1070            name == "SAME"
1071            && delimiter == &Some(String::from(":"))
1072            &&  matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
1073        => {
1074            let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
1075            let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1076            let field_option = arg_vec.get(0);
1077            let field_option_unwrapped = field_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1078            let field_option_unwrapped_primitive = extract_primitive_from_field(field_option_unwrapped, &arguments)?;
1079            let field = extract_int_from_primitive(field_option_unwrapped_primitive, &arguments)?;
1080            Ok(highlevel::Success::SameTwo {
1081                field,
1082            })
1083        },
1084        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1085            name == "BRSF"
1086            && delimiter == &Some(String::from(":"))
1087            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1088        => {
1089            let arg_vec = extract_vec_from_args(&arguments)?;
1090            let features_option = arg_vec.get(0);
1091            let features_option_unwrapped = features_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1092            let features_option_unwrapped_primitive = extract_primitive_from_field(features_option_unwrapped, &arguments)?;
1093            let features = extract_int_from_primitive(features_option_unwrapped_primitive, &arguments)?;
1094            Ok(highlevel::Success::Brsf {
1095                features,
1096            })
1097        },
1098        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1099            name == "CIND"
1100            && delimiter == &Some(String::from(":"))
1101            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1102        => {
1103            let arg_vec = extract_vec_from_args(&arguments)?;
1104            let mut ordered_values = Vec::new();
1105            for ordered_values_element_raw in arg_vec[0..].into_iter() {
1106                let ordered_values_element_option = if ordered_values_element_raw.is_empty() { None } else { Some(ordered_values_element_raw) };
1107                let ordered_values_element_option_unwrapped = ordered_values_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1108                let ordered_values_element_option_unwrapped_primitive = extract_primitive_from_field(ordered_values_element_option_unwrapped, &arguments)?;
1109                let ordered_values_element = extract_int_from_primitive(ordered_values_element_option_unwrapped_primitive, &arguments)?;
1110                ordered_values.push(ordered_values_element);
1111            }
1112            Ok(highlevel::Success::CindRead {
1113                ordered_values,
1114            })
1115        },
1116        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1117            name == "CLCC"
1118            && delimiter == &Some(String::from(":"))
1119            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1120        => {
1121            let arg_vec = extract_vec_from_args(&arguments)?;
1122            let index_option = arg_vec.get(0);
1123            let index_option_unwrapped = index_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1124            let index_option_unwrapped_primitive = extract_primitive_from_field(index_option_unwrapped, &arguments)?;
1125            let index = extract_int_from_primitive(index_option_unwrapped_primitive, &arguments)?;
1126            let dir_option = arg_vec.get(1);
1127            let dir_option_unwrapped = dir_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1128            let dir_option_unwrapped_primitive = extract_primitive_from_field(dir_option_unwrapped, &arguments)?;
1129            let dir = extract_int_from_primitive(dir_option_unwrapped_primitive, &arguments)?;
1130            let status_option = arg_vec.get(2);
1131            let status_option_unwrapped = status_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1132            let status_option_unwrapped_primitive = extract_primitive_from_field(status_option_unwrapped, &arguments)?;
1133            let status = extract_int_from_primitive(status_option_unwrapped_primitive, &arguments)?;
1134            let mode_option = arg_vec.get(3);
1135            let mode_option_unwrapped = mode_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1136            let mode_option_unwrapped_primitive = extract_primitive_from_field(mode_option_unwrapped, &arguments)?;
1137            let mode = extract_int_from_primitive(mode_option_unwrapped_primitive, &arguments)?;
1138            let mpty_option = arg_vec.get(4);
1139            let mpty_option_unwrapped = mpty_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1140            let mpty_option_unwrapped_primitive = extract_primitive_from_field(mpty_option_unwrapped, &arguments)?;
1141            let mpty = extract_int_from_primitive(mpty_option_unwrapped_primitive, &arguments)?;
1142            let number_option = arg_vec.get(5);
1143            let number_option_unwrapped = number_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1144            let number_option_unwrapped_primitive = extract_primitive_from_field(number_option_unwrapped, &arguments)?;
1145            let number = number_option_unwrapped_primitive.clone();
1146            let ty_option = arg_vec.get(6);
1147            let ty_option_unwrapped = ty_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1148            let ty_option_unwrapped_primitive = extract_primitive_from_field(ty_option_unwrapped, &arguments)?;
1149            let ty = extract_int_from_primitive(ty_option_unwrapped_primitive, &arguments)?;
1150            Ok(highlevel::Success::Clcc {
1151                index,
1152                dir,
1153                status,
1154                mode,
1155                mpty,
1156                number,
1157                ty,
1158            })
1159        },
1160        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1161            name == "BCS"
1162            && delimiter == &Some(String::from(":"))
1163            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1164        => {
1165            let arg_vec = extract_vec_from_args(&arguments)?;
1166            let codec_option = arg_vec.get(0);
1167            let codec_option_unwrapped = codec_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1168            let codec_option_unwrapped_primitive = extract_primitive_from_field(codec_option_unwrapped, &arguments)?;
1169            let codec = extract_int_from_primitive(codec_option_unwrapped_primitive, &arguments)?;
1170            Ok(highlevel::Success::Bcs {
1171                codec,
1172            })
1173        },
1174        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1175            name == "BIND"
1176            && delimiter == &Some(String::from(":"))
1177            &&  matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
1178        => {
1179            let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
1180            let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1181            let mut indicators = Vec::new();
1182            for indicators_element_raw in arg_vec[0..].into_iter() {
1183                let indicators_element_option = if indicators_element_raw.is_empty() { None } else { Some(indicators_element_raw) };
1184                let indicators_element_option_unwrapped = indicators_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1185                let indicators_element_option_unwrapped_primitive = extract_primitive_from_field(indicators_element_option_unwrapped, &arguments)?;
1186                let indicators_element_option_unwrapped_int = extract_int_from_primitive(indicators_element_option_unwrapped_primitive, &arguments)?;
1187                let indicators_element = super::types::BluetoothHFIndicator::from_i64(indicators_element_option_unwrapped_int).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1188                indicators.push(indicators_element);
1189            }
1190            Ok(highlevel::Success::BindList {
1191                indicators,
1192            })
1193        },
1194        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1195            name == "BIND"
1196            && delimiter == &Some(String::from(":"))
1197            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1198        => {
1199            let arg_vec = extract_vec_from_args(&arguments)?;
1200            let anum_option = arg_vec.get(0);
1201            let anum_option_unwrapped = anum_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1202            let anum_option_unwrapped_primitive = extract_primitive_from_field(anum_option_unwrapped, &arguments)?;
1203            let anum_option_unwrapped_int = extract_int_from_primitive(anum_option_unwrapped_primitive, &arguments)?;
1204            let anum = super::types::BluetoothHFIndicator::from_i64(anum_option_unwrapped_int).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1205            let state_option = arg_vec.get(1);
1206            let state_option_unwrapped = state_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1207            let state_option_unwrapped_primitive = extract_primitive_from_field(state_option_unwrapped, &arguments)?;
1208            let state_option_unwrapped_int = extract_int_from_primitive(state_option_unwrapped_primitive, &arguments)?;
1209            let state = state_option_unwrapped_int != 0;
1210            Ok(highlevel::Success::BindStatus {
1211                anum,
1212                state,
1213            })
1214        },
1215        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1216            name == "CHLD"
1217            && delimiter == &Some(String::from(":"))
1218            &&  matches!(arguments, lowlevel::Arguments::ParenthesisDelimitedArgumentLists(_))
1219        => {
1220            let arg_vec_vec = extract_vec_vec_from_args(&arguments)?;
1221            let arg_vec = arg_vec_vec.get(0).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1222            let mut commands = Vec::new();
1223            for commands_element_raw in arg_vec[0..].into_iter() {
1224                let commands_element_option = if commands_element_raw.is_empty() { None } else { Some(commands_element_raw) };
1225                let commands_element_option_unwrapped = commands_element_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1226                let commands_element_option_unwrapped_primitive = extract_primitive_from_field(commands_element_option_unwrapped, &arguments)?;
1227                let commands_element = commands_element_option_unwrapped_primitive.clone();
1228                commands.push(commands_element);
1229            }
1230            Ok(highlevel::Success::Chld {
1231                commands,
1232            })
1233        },
1234        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1235            name == "COPS"
1236            && delimiter == &Some(String::from(":"))
1237            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1238        => {
1239            let arg_vec = extract_vec_from_args(&arguments)?;
1240            let format_option = arg_vec.get(0);
1241            let format_option_unwrapped = format_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1242            let format_option_unwrapped_primitive = extract_primitive_from_field(format_option_unwrapped, &arguments)?;
1243            let format_option_unwrapped_int = extract_int_from_primitive(format_option_unwrapped_primitive, &arguments)?;
1244            let format = super::types::NetworkOperatorNameFormat::from_i64(format_option_unwrapped_int).ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1245            let zero_option = arg_vec.get(1);
1246            let zero_option_unwrapped = zero_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1247            let zero_option_unwrapped_primitive = extract_primitive_from_field(zero_option_unwrapped, &arguments)?;
1248            let zero = extract_int_from_primitive(zero_option_unwrapped_primitive, &arguments)?;
1249            let operator_option = arg_vec.get(2);
1250            let operator_option_unwrapped = operator_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1251            let operator_option_unwrapped_primitive = extract_primitive_from_field(operator_option_unwrapped, &arguments)?;
1252            let operator = operator_option_unwrapped_primitive.clone();
1253            Ok(highlevel::Success::Cops {
1254                format,
1255                zero,
1256                operator,
1257            })
1258        },
1259        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1260            name == "CLIP"
1261            && delimiter == &Some(String::from(":"))
1262            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1263        => {
1264            let arg_vec = extract_vec_from_args(&arguments)?;
1265            let number_option = arg_vec.get(0);
1266            let number_option_unwrapped = number_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1267            let number_option_unwrapped_primitive = extract_primitive_from_field(number_option_unwrapped, &arguments)?;
1268            let number = number_option_unwrapped_primitive.clone();
1269            let ty_option = arg_vec.get(1);
1270            let ty_option_unwrapped = ty_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1271            let ty_option_unwrapped_primitive = extract_primitive_from_field(ty_option_unwrapped, &arguments)?;
1272            let ty = extract_int_from_primitive(ty_option_unwrapped_primitive, &arguments)?;
1273            Ok(highlevel::Success::Clip {
1274                number,
1275                ty,
1276            })
1277        },
1278        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1279            name == "CNUM"
1280            && delimiter == &Some(String::from(":"))
1281            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1282        => {
1283            let arg_vec = extract_vec_from_args(&arguments)?;
1284            let alpha_option = arg_vec.get(0);
1285            let alpha_option_unwrapped = alpha_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1286            let alpha_option_unwrapped_primitive = extract_primitive_from_field(alpha_option_unwrapped, &arguments)?;
1287            let alpha = alpha_option_unwrapped_primitive.clone();
1288            let number_option = arg_vec.get(1);
1289            let number_option_unwrapped = number_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1290            let number_option_unwrapped_primitive = extract_primitive_from_field(number_option_unwrapped, &arguments)?;
1291            let number = number_option_unwrapped_primitive.clone();
1292            let ty_option = arg_vec.get(2);
1293            let ty_option_unwrapped = ty_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1294            let ty_option_unwrapped_primitive = extract_primitive_from_field(ty_option_unwrapped, &arguments)?;
1295            let ty = extract_int_from_primitive(ty_option_unwrapped_primitive, &arguments)?;
1296            let speed_option = arg_vec.get(3);
1297            let speed_option_unwrapped = speed_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1298            let speed_option_unwrapped_primitive = extract_primitive_from_field(speed_option_unwrapped, &arguments)?;
1299            let speed = speed_option_unwrapped_primitive.clone();
1300            let service_option = arg_vec.get(4);
1301            let service_option_unwrapped = service_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1302            let service_option_unwrapped_primitive = extract_primitive_from_field(service_option_unwrapped, &arguments)?;
1303            let service = extract_int_from_primitive(service_option_unwrapped_primitive, &arguments)?;
1304            Ok(highlevel::Success::Cnum {
1305                alpha,
1306                number,
1307                ty,
1308                speed,
1309                service,
1310            })
1311        },
1312        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1313            name == "VGS"
1314            && delimiter == &Some(String::from(":"))
1315            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1316        => {
1317            let arg_vec = extract_vec_from_args(&arguments)?;
1318            let level_option = arg_vec.get(0);
1319            let level_option_unwrapped = level_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1320            let level_option_unwrapped_primitive = extract_primitive_from_field(level_option_unwrapped, &arguments)?;
1321            let level = extract_int_from_primitive(level_option_unwrapped_primitive, &arguments)?;
1322            Ok(highlevel::Success::Vgs {
1323                level,
1324            })
1325        },
1326        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1327            name == "VGM"
1328            && delimiter == &Some(String::from(":"))
1329            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1330        => {
1331            let arg_vec = extract_vec_from_args(&arguments)?;
1332            let level_option = arg_vec.get(0);
1333            let level_option_unwrapped = level_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1334            let level_option_unwrapped_primitive = extract_primitive_from_field(level_option_unwrapped, &arguments)?;
1335            let level = extract_int_from_primitive(level_option_unwrapped_primitive, &arguments)?;
1336            Ok(highlevel::Success::Vgm {
1337                level,
1338            })
1339        },
1340        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1341            name == "CIEV"
1342            && delimiter == &Some(String::from(":"))
1343            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1344        => {
1345            let arg_vec = extract_vec_from_args(&arguments)?;
1346            let ind_option = arg_vec.get(0);
1347            let ind_option_unwrapped = ind_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1348            let ind_option_unwrapped_primitive = extract_primitive_from_field(ind_option_unwrapped, &arguments)?;
1349            let ind = extract_int_from_primitive(ind_option_unwrapped_primitive, &arguments)?;
1350            let value_option = arg_vec.get(1);
1351            let value_option_unwrapped = value_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1352            let value_option_unwrapped_primitive = extract_primitive_from_field(value_option_unwrapped, &arguments)?;
1353            let value = extract_int_from_primitive(value_option_unwrapped_primitive, &arguments)?;
1354            Ok(highlevel::Success::Ciev {
1355                ind,
1356                value,
1357            })
1358        },
1359        lowlevel::Response::Success { name, is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter, arguments, .. }} if
1360            name == "CCWA"
1361            && delimiter == &Some(String::from(":"))
1362            &&  matches!(arguments, lowlevel::Arguments::ArgumentList(_))
1363        => {
1364            let arg_vec = extract_vec_from_args(&arguments)?;
1365            let number_option = arg_vec.get(0);
1366            let number_option_unwrapped = number_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1367            let number_option_unwrapped_primitive = extract_primitive_from_field(number_option_unwrapped, &arguments)?;
1368            let number = number_option_unwrapped_primitive.clone();
1369            let ty_option = arg_vec.get(1);
1370            let ty_option_unwrapped = ty_option.ok_or_else(|| DeserializeErrorCause::UnknownArguments(arguments.clone()))?;
1371            let ty_option_unwrapped_primitive = extract_primitive_from_field(ty_option_unwrapped, &arguments)?;
1372            let ty = extract_int_from_primitive(ty_option_unwrapped_primitive, &arguments)?;
1373            Ok(highlevel::Success::Ccwa {
1374                number,
1375                ty,
1376            })
1377        },
1378        lowlevel::Response::Success { name, is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter, .. }} if
1379            name == "RING"
1380            && delimiter == &None
1381        => {
1382            Ok(highlevel::Success::Ring {
1383            })
1384        },
1385        _ => Err(DeserializeErrorCause::UnknownResponse(lowlevel.clone())),
1386    }
1387}
1388
1389pub fn lower_command(highlevel: &highlevel::Command) -> lowlevel::Command {
1390    match highlevel {
1391        highlevel::Command::Testex {        } => {
1392            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1393            lowlevel::Command::Execute { name: String::from("TESTEX"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1394        },
1395        highlevel::Command::Testexext {        } => {
1396            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1397            lowlevel::Command::Execute { name: String::from("TESTEXEXT"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1398        },
1399        highlevel::Command::TestCommand {        } => {
1400            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1401            lowlevel::Command::Execute { name: String::from("TESTNEX"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1402        },
1403        highlevel::Command::Testexextfi {
1404            field,
1405        } => {
1406            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1407            let field_string = i64::to_string(&field);
1408            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1409            raw_arguments.push(field_primitive);
1410            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1411            lowlevel::Command::Execute { name: String::from("TESTEXEXTFI"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1412        },
1413        highlevel::Command::Testexextfic {
1414            field,
1415        } => {
1416            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1417            let field_string = i64::to_string(&field);
1418            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1419            raw_arguments.push(field_primitive);
1420            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1421            lowlevel::Command::Execute { name: String::from("TESTEXEXTFIC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1422        },
1423        highlevel::Command::Testnsd {
1424            field,
1425        } => {
1426            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1427            let field_string = i64::to_string(&field);
1428            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1429            raw_arguments.push(field_primitive);
1430            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1431            lowlevel::Command::Execute { name: String::from("TESTNSD"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(">")), arguments, terminator: None } }
1432        },
1433        highlevel::Command::Testnst {
1434            field,
1435        } => {
1436            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1437            let field_string = i64::to_string(&field);
1438            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1439            raw_arguments.push(field_primitive);
1440            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1441            lowlevel::Command::Execute { name: String::from("TESTNST"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: Some(String::from(";")) } }
1442        },
1443        highlevel::Command::Testnsdnst {
1444            field,
1445        } => {
1446            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1447            let field_string = i64::to_string(&field);
1448            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1449            raw_arguments.push(field_primitive);
1450            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1451            lowlevel::Command::Execute { name: String::from("TESTNSDNST"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(">")), arguments, terminator: Some(String::from(";")) } }
1452        },
1453        highlevel::Command::Testnod {
1454            field,
1455        } => {
1456            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1457            let field_string = i64::to_string(&field);
1458            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1459            raw_arguments.push(field_primitive);
1460            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1461            lowlevel::Command::Execute { name: String::from("TESTNOD"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1462        },
1463        highlevel::Command::Testexextfs {
1464            field,
1465        } => {
1466            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1467            let field_string = field.clone();
1468            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1469            raw_arguments.push(field_primitive);
1470            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1471            lowlevel::Command::Execute { name: String::from("TESTEXEXTFS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1472        },
1473        highlevel::Command::Testexextfsi {
1474            field1,
1475            field2,
1476        } => {
1477            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1478            let field1_string = field1.clone();
1479            let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
1480            raw_arguments.push(field1_primitive);
1481            let field2_string = i64::to_string(&field2);
1482            let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
1483            raw_arguments.push(field2_primitive);
1484            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1485            lowlevel::Command::Execute { name: String::from("TESTEXEXTFSI"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1486        },
1487        highlevel::Command::Testexextfsic {
1488            field1,
1489            field2,
1490        } => {
1491            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1492            let field1_string = field1.clone();
1493            let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
1494            raw_arguments.push(field1_primitive);
1495            let field2_string = i64::to_string(&field2);
1496            let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
1497            raw_arguments.push(field2_primitive);
1498            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1499            lowlevel::Command::Execute { name: String::from("TESTEXEXTFSIC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1500        },
1501        highlevel::Command::Testio {
1502            field1,
1503            field2,
1504        } => {
1505            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1506            let field1_string = i64::to_string(&field1);
1507            let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
1508            raw_arguments.push(field1_primitive);
1509            match field2 {
1510            None => {
1511                        raw_arguments.push(lowlevel::Argument::PrimitiveArgument(String::new()));
1512                }
1513                Some(field2_unwrapped) => {
1514                        let field2_unwrapped_string = i64::to_string(&field2_unwrapped);
1515                        let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_unwrapped_string);
1516                        raw_arguments.push(field2_primitive);
1517                }
1518            }
1519            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1520            lowlevel::Command::Execute { name: String::from("TESTIO"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1521        },
1522        highlevel::Command::Testl {
1523            field,
1524        } => {
1525            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1526            for field_element in field.into_iter() {
1527                    let field_element_string = i64::to_string(&field_element);
1528                    let field_element_primitive = lowlevel::Argument::PrimitiveArgument(field_element_string);
1529                    raw_arguments.push(field_element_primitive);
1530            }   
1531            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1532            lowlevel::Command::Execute { name: String::from("TESTL"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1533        },
1534        highlevel::Command::Testol {
1535            field,
1536        } => {
1537            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1538            for field_element in field.into_iter() {
1539                    match field_element {
1540                    None => {
1541                                raw_arguments.push(lowlevel::Argument::PrimitiveArgument(String::new()));
1542                        }
1543                        Some(field_element_unwrapped) => {
1544                                let field_element_unwrapped_string = i64::to_string(&field_element_unwrapped);
1545                                let field_element_primitive = lowlevel::Argument::PrimitiveArgument(field_element_unwrapped_string);
1546                                raw_arguments.push(field_element_primitive);
1547                        }
1548                    }
1549            }   
1550            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1551            lowlevel::Command::Execute { name: String::from("TESTOL"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1552        },
1553        highlevel::Command::Testm {
1554            field,
1555        } => {
1556            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1557            for (field_typed_key, field_typed_value) in field {
1558                let field_primitive_key = i64::to_string(&field_typed_key);
1559                let field_primitive_value = field_typed_value.clone();
1560                let field_untyped_pair = lowlevel::Argument::KeyValueArgument { key: field_primitive_key, value: field_primitive_value };
1561                raw_arguments.push(field_untyped_pair);
1562            }   
1563            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1564            lowlevel::Command::Execute { name: String::from("TESTM"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1565        },
1566        highlevel::Command::Testp {
1567            field,
1568        } => {
1569            let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
1570            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
1571            let field_string = i64::to_string(&field);
1572            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1573            raw_arguments_inner.push(field_primitive);
1574            raw_arguments_outer.push(raw_arguments_inner);
1575            let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
1576            lowlevel::Command::Execute { name: String::from("TESTP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1577        },
1578        highlevel::Command::Testpp {
1579            field1,
1580            field2,
1581            field3,
1582        } => {
1583            let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
1584            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
1585            let field1_string = i64::to_string(&field1);
1586            let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
1587            raw_arguments_inner.push(field1_primitive);
1588            raw_arguments_outer.push(raw_arguments_inner);
1589            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
1590            let field2_string = i64::to_string(&field2);
1591            let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
1592            raw_arguments_inner.push(field2_primitive);
1593            let field3_string = field3.clone();
1594            let field3_primitive = lowlevel::Argument::PrimitiveArgument(field3_string);
1595            raw_arguments_inner.push(field3_primitive);
1596            raw_arguments_outer.push(raw_arguments_inner);
1597            let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
1598            lowlevel::Command::Execute { name: String::from("TESTPP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1599        },
1600        highlevel::Command::Testpmpil {
1601            field1,
1602            field2,
1603            field3,
1604        } => {
1605            let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
1606            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
1607            for (field1_typed_key, field1_typed_value) in field1 {
1608                let field1_primitive_key = i64::to_string(&field1_typed_key);
1609                let field1_primitive_value = field1_typed_value.clone();
1610                let field1_untyped_pair = lowlevel::Argument::KeyValueArgument { key: field1_primitive_key, value: field1_primitive_value };
1611                raw_arguments_inner.push(field1_untyped_pair);
1612            }   
1613            raw_arguments_outer.push(raw_arguments_inner);
1614            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
1615            let field2_string = i64::to_string(&field2);
1616            let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
1617            raw_arguments_inner.push(field2_primitive);
1618            for field3_element in field3.into_iter() {
1619                    let field3_element_string = i64::to_string(&field3_element);
1620                    let field3_element_primitive = lowlevel::Argument::PrimitiveArgument(field3_element_string);
1621                    raw_arguments_inner.push(field3_element_primitive);
1622            }   
1623            raw_arguments_outer.push(raw_arguments_inner);
1624            let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
1625            lowlevel::Command::Execute { name: String::from("TESTPMPIL"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1626        },
1627        highlevel::Command::TestrRead {} => {
1628            lowlevel::Command::Read { name: String::from("TESTR"), is_extension: false }
1629        },
1630        highlevel::Command::TestrexRead {} => {
1631            lowlevel::Command::Read { name: String::from("TESTREX"), is_extension: true }
1632        },
1633        highlevel::Command::TesttTest {} => {
1634            lowlevel::Command::Test { name: String::from("TESTT"), is_extension: false }
1635        },
1636        highlevel::Command::TesttexTest {} => {
1637            lowlevel::Command::Test { name: String::from("TESTTEX"), is_extension: true }
1638        },
1639        highlevel::Command::Testenum {
1640            field,
1641        } => {
1642            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1643            let field_string_int = *field as i64;
1644            let field_string = i64::to_string(&field_string_int);
1645            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1646            raw_arguments.push(field_primitive);
1647            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1648            lowlevel::Command::Execute { name: String::from("TESTENUM"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1649        },
1650        highlevel::Command::Testbool {
1651            field,
1652        } => {
1653            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1654            let field_string_int = if *field { 1 } else { 0 };
1655            let field_string = i64::to_string(&field_string_int);
1656            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1657            raw_arguments.push(field_primitive);
1658            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1659            lowlevel::Command::Execute { name: String::from("TESTBOOL"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1660        },
1661        highlevel::Command::Testotherfile {        } => {
1662            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1663            lowlevel::Command::Execute { name: String::from("TESTOTHERFILE"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1664        },
1665        highlevel::Command::Brsf {
1666            features,
1667        } => {
1668            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1669            let features_string = i64::to_string(&features);
1670            let features_primitive = lowlevel::Argument::PrimitiveArgument(features_string);
1671            raw_arguments.push(features_primitive);
1672            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1673            lowlevel::Command::Execute { name: String::from("BRSF"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1674        },
1675        highlevel::Command::CindTest {} => {
1676            lowlevel::Command::Test { name: String::from("CIND"), is_extension: true }
1677        },
1678        highlevel::Command::CindRead {} => {
1679            lowlevel::Command::Read { name: String::from("CIND"), is_extension: true }
1680        },
1681        highlevel::Command::Clcc {        } => {
1682            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1683            lowlevel::Command::Execute { name: String::from("CLCC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1684        },
1685        highlevel::Command::Bcc {        } => {
1686            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1687            lowlevel::Command::Execute { name: String::from("BCC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1688        },
1689        highlevel::Command::Bcs {
1690            codec,
1691        } => {
1692            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1693            let codec_string = i64::to_string(&codec);
1694            let codec_primitive = lowlevel::Argument::PrimitiveArgument(codec_string);
1695            raw_arguments.push(codec_primitive);
1696            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1697            lowlevel::Command::Execute { name: String::from("BCS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1698        },
1699        highlevel::Command::Bac {
1700            codecs,
1701        } => {
1702            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1703            for codecs_element in codecs.into_iter() {
1704                    let codecs_element_string = i64::to_string(&codecs_element);
1705                    let codecs_element_primitive = lowlevel::Argument::PrimitiveArgument(codecs_element_string);
1706                    raw_arguments.push(codecs_element_primitive);
1707            }   
1708            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1709            lowlevel::Command::Execute { name: String::from("BAC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1710        },
1711        highlevel::Command::Bind {
1712            indicators,
1713        } => {
1714            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1715            for indicators_element in indicators.into_iter() {
1716                    let indicators_element_string = i64::to_string(&indicators_element);
1717                    let indicators_element_primitive = lowlevel::Argument::PrimitiveArgument(indicators_element_string);
1718                    raw_arguments.push(indicators_element_primitive);
1719            }   
1720            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1721            lowlevel::Command::Execute { name: String::from("BIND"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1722        },
1723        highlevel::Command::BindTest {} => {
1724            lowlevel::Command::Test { name: String::from("BIND"), is_extension: true }
1725        },
1726        highlevel::Command::BindRead {} => {
1727            lowlevel::Command::Read { name: String::from("BIND"), is_extension: true }
1728        },
1729        highlevel::Command::Biev {
1730            anum,
1731            value,
1732        } => {
1733            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1734            let anum_string_int = *anum as i64;
1735            let anum_string = i64::to_string(&anum_string_int);
1736            let anum_primitive = lowlevel::Argument::PrimitiveArgument(anum_string);
1737            raw_arguments.push(anum_primitive);
1738            let value_string = i64::to_string(&value);
1739            let value_primitive = lowlevel::Argument::PrimitiveArgument(value_string);
1740            raw_arguments.push(value_primitive);
1741            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1742            lowlevel::Command::Execute { name: String::from("BIEV"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1743        },
1744        highlevel::Command::ChldTest {} => {
1745            lowlevel::Command::Test { name: String::from("CHLD"), is_extension: true }
1746        },
1747        highlevel::Command::Cmer {
1748            mode,
1749            keyp,
1750            disp,
1751            ind,
1752        } => {
1753            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1754            let mode_string = i64::to_string(&mode);
1755            let mode_primitive = lowlevel::Argument::PrimitiveArgument(mode_string);
1756            raw_arguments.push(mode_primitive);
1757            let keyp_string = i64::to_string(&keyp);
1758            let keyp_primitive = lowlevel::Argument::PrimitiveArgument(keyp_string);
1759            raw_arguments.push(keyp_primitive);
1760            let disp_string = i64::to_string(&disp);
1761            let disp_primitive = lowlevel::Argument::PrimitiveArgument(disp_string);
1762            raw_arguments.push(disp_primitive);
1763            let ind_string = i64::to_string(&ind);
1764            let ind_primitive = lowlevel::Argument::PrimitiveArgument(ind_string);
1765            raw_arguments.push(ind_primitive);
1766            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1767            lowlevel::Command::Execute { name: String::from("CMER"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1768        },
1769        highlevel::Command::Nrec {
1770            nrec,
1771        } => {
1772            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1773            let nrec_string_int = if *nrec { 1 } else { 0 };
1774            let nrec_string = i64::to_string(&nrec_string_int);
1775            let nrec_primitive = lowlevel::Argument::PrimitiveArgument(nrec_string);
1776            raw_arguments.push(nrec_primitive);
1777            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1778            lowlevel::Command::Execute { name: String::from("NREC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1779        },
1780        highlevel::Command::Cops {
1781            three,
1782            format,
1783        } => {
1784            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1785            let three_string = i64::to_string(&three);
1786            let three_primitive = lowlevel::Argument::PrimitiveArgument(three_string);
1787            raw_arguments.push(three_primitive);
1788            let format_string_int = *format as i64;
1789            let format_string = i64::to_string(&format_string_int);
1790            let format_primitive = lowlevel::Argument::PrimitiveArgument(format_string);
1791            raw_arguments.push(format_primitive);
1792            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1793            lowlevel::Command::Execute { name: String::from("COPS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1794        },
1795        highlevel::Command::CopsRead {} => {
1796            lowlevel::Command::Read { name: String::from("COPS"), is_extension: true }
1797        },
1798        highlevel::Command::Cmee {
1799            enable,
1800        } => {
1801            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1802            let enable_string_int = if *enable { 1 } else { 0 };
1803            let enable_string = i64::to_string(&enable_string_int);
1804            let enable_primitive = lowlevel::Argument::PrimitiveArgument(enable_string);
1805            raw_arguments.push(enable_primitive);
1806            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1807            lowlevel::Command::Execute { name: String::from("CMEE"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1808        },
1809        highlevel::Command::Ccwa {
1810            enable,
1811        } => {
1812            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1813            let enable_string_int = if *enable { 1 } else { 0 };
1814            let enable_string = i64::to_string(&enable_string_int);
1815            let enable_primitive = lowlevel::Argument::PrimitiveArgument(enable_string);
1816            raw_arguments.push(enable_primitive);
1817            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1818            lowlevel::Command::Execute { name: String::from("CCWA"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1819        },
1820        highlevel::Command::Clip {
1821            enable,
1822        } => {
1823            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1824            let enable_string_int = if *enable { 1 } else { 0 };
1825            let enable_string = i64::to_string(&enable_string_int);
1826            let enable_primitive = lowlevel::Argument::PrimitiveArgument(enable_string);
1827            raw_arguments.push(enable_primitive);
1828            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1829            lowlevel::Command::Execute { name: String::from("CLIP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1830        },
1831        highlevel::Command::Cnum {        } => {
1832            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1833            lowlevel::Command::Execute { name: String::from("CNUM"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1834        },
1835        highlevel::Command::Vts {
1836            code,
1837        } => {
1838            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1839            let code_string = code.clone();
1840            let code_primitive = lowlevel::Argument::PrimitiveArgument(code_string);
1841            raw_arguments.push(code_primitive);
1842            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1843            lowlevel::Command::Execute { name: String::from("VTS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1844        },
1845        highlevel::Command::Vgs {
1846            level,
1847        } => {
1848            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1849            let level_string = i64::to_string(&level);
1850            let level_primitive = lowlevel::Argument::PrimitiveArgument(level_string);
1851            raw_arguments.push(level_primitive);
1852            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1853            lowlevel::Command::Execute { name: String::from("VGS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1854        },
1855        highlevel::Command::Vgm {
1856            level,
1857        } => {
1858            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1859            let level_string = i64::to_string(&level);
1860            let level_primitive = lowlevel::Argument::PrimitiveArgument(level_string);
1861            raw_arguments.push(level_primitive);
1862            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1863            lowlevel::Command::Execute { name: String::from("VGM"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1864        },
1865        highlevel::Command::Bia {
1866            indrep,
1867        } => {
1868            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1869            for indrep_element in indrep.into_iter() {
1870                    match indrep_element {
1871                    None => {
1872                                raw_arguments.push(lowlevel::Argument::PrimitiveArgument(String::new()));
1873                        }
1874                        Some(indrep_element_unwrapped) => {
1875                                let indrep_element_unwrapped_string_int = if *indrep_element_unwrapped { 1 } else { 0 };
1876                                let indrep_element_unwrapped_string = i64::to_string(&indrep_element_unwrapped_string_int);
1877                                let indrep_element_primitive = lowlevel::Argument::PrimitiveArgument(indrep_element_unwrapped_string);
1878                                raw_arguments.push(indrep_element_primitive);
1879                        }
1880                    }
1881            }   
1882            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1883            lowlevel::Command::Execute { name: String::from("BIA"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1884        },
1885        highlevel::Command::Answer {        } => {
1886            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1887            lowlevel::Command::Execute { name: String::from("A"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1888        },
1889        highlevel::Command::Chup {        } => {
1890            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1891            lowlevel::Command::Execute { name: String::from("CHUP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1892        },
1893        highlevel::Command::Chld {
1894            command,
1895        } => {
1896            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1897            let command_string = command.clone();
1898            let command_primitive = lowlevel::Argument::PrimitiveArgument(command_string);
1899            raw_arguments.push(command_primitive);
1900            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1901            lowlevel::Command::Execute { name: String::from("CHLD"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from("=")), arguments, terminator: None } }
1902        },
1903        highlevel::Command::AtdNumber {
1904            number,
1905        } => {
1906            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1907            let number_string = number.clone();
1908            let number_primitive = lowlevel::Argument::PrimitiveArgument(number_string);
1909            raw_arguments.push(number_primitive);
1910            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1911            lowlevel::Command::Execute { name: String::from("D"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: Some(String::from(";")) } }
1912        },
1913        highlevel::Command::AtdMemory {
1914            location,
1915        } => {
1916            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1917            let location_string = location.clone();
1918            let location_primitive = lowlevel::Argument::PrimitiveArgument(location_string);
1919            raw_arguments.push(location_primitive);
1920            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1921            lowlevel::Command::Execute { name: String::from("D"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(">")), arguments, terminator: Some(String::from(";")) } }
1922        },
1923        highlevel::Command::Bldn {        } => {
1924            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1925            lowlevel::Command::Execute { name: String::from("BLDN"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1926        },
1927    }
1928}
1929
1930pub fn lower_success(highlevel: &highlevel::Success) -> lowlevel::Response {
1931    match highlevel {
1932        highlevel::Success::Test {        } => {
1933            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1934            lowlevel::Response::Success { name: String::from("TEST"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
1935        },
1936        highlevel::Success::Testnod {        } => {
1937            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1938            lowlevel::Response::Success { name: String::from("TESTNOD"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1939        },
1940        highlevel::Success::TestResponse {        } => {
1941            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1942            lowlevel::Response::Success { name: String::from("TESTN"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
1943        },
1944        highlevel::Success::Testext {        } => {
1945            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1946            lowlevel::Response::Success { name: String::from("TESTEXT"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
1947        },
1948        highlevel::Success::Testextnod {        } => {
1949            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
1950            lowlevel::Response::Success { name: String::from("TESTEXTNOD"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1951        },
1952        highlevel::Success::Testi {
1953            field,
1954        } => {
1955            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1956            let field_string = i64::to_string(&field);
1957            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1958            raw_arguments.push(field_primitive);
1959            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1960            lowlevel::Response::Success { name: String::from("TESTI"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
1961        },
1962        highlevel::Success::Testinod {
1963            field,
1964        } => {
1965            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1966            let field_string = i64::to_string(&field);
1967            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1968            raw_arguments.push(field_primitive);
1969            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1970            lowlevel::Response::Success { name: String::from("TESTINOD"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
1971        },
1972        highlevel::Success::Testic {
1973            field,
1974        } => {
1975            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1976            let field_string = i64::to_string(&field);
1977            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1978            raw_arguments.push(field_primitive);
1979            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1980            lowlevel::Response::Success { name: String::from("TESTIC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
1981        },
1982        highlevel::Success::Tests {
1983            field,
1984        } => {
1985            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1986            let field_string = field.clone();
1987            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
1988            raw_arguments.push(field_primitive);
1989            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
1990            lowlevel::Response::Success { name: String::from("TESTS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
1991        },
1992        highlevel::Success::Testsi {
1993            field1,
1994            field2,
1995        } => {
1996            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
1997            let field1_string = field1.clone();
1998            let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
1999            raw_arguments.push(field1_primitive);
2000            let field2_string = i64::to_string(&field2);
2001            let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
2002            raw_arguments.push(field2_primitive);
2003            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2004            lowlevel::Response::Success { name: String::from("TESTSI"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2005        },
2006        highlevel::Success::Testsic {
2007            field1,
2008            field2,
2009        } => {
2010            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2011            let field1_string = field1.clone();
2012            let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
2013            raw_arguments.push(field1_primitive);
2014            let field2_string = i64::to_string(&field2);
2015            let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
2016            raw_arguments.push(field2_primitive);
2017            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2018            lowlevel::Response::Success { name: String::from("TESTSIC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2019        },
2020        highlevel::Success::Testio {
2021            field1,
2022            field2,
2023        } => {
2024            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2025            let field1_string = i64::to_string(&field1);
2026            let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
2027            raw_arguments.push(field1_primitive);
2028            match field2 {
2029            None => {
2030                        raw_arguments.push(lowlevel::Argument::PrimitiveArgument(String::new()));
2031                }
2032                Some(field2_unwrapped) => {
2033                        let field2_unwrapped_string = i64::to_string(&field2_unwrapped);
2034                        let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_unwrapped_string);
2035                        raw_arguments.push(field2_primitive);
2036                }
2037            }
2038            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2039            lowlevel::Response::Success { name: String::from("TESTIO"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2040        },
2041        highlevel::Success::Testl {
2042            field,
2043        } => {
2044            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2045            for field_element in field.into_iter() {
2046                    let field_element_string = i64::to_string(&field_element);
2047                    let field_element_primitive = lowlevel::Argument::PrimitiveArgument(field_element_string);
2048                    raw_arguments.push(field_element_primitive);
2049            }   
2050            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2051            lowlevel::Response::Success { name: String::from("TESTL"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2052        },
2053        highlevel::Success::Testol {
2054            field,
2055        } => {
2056            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2057            for field_element in field.into_iter() {
2058                    match field_element {
2059                    None => {
2060                                raw_arguments.push(lowlevel::Argument::PrimitiveArgument(String::new()));
2061                        }
2062                        Some(field_element_unwrapped) => {
2063                                let field_element_unwrapped_string = i64::to_string(&field_element_unwrapped);
2064                                let field_element_primitive = lowlevel::Argument::PrimitiveArgument(field_element_unwrapped_string);
2065                                raw_arguments.push(field_element_primitive);
2066                        }
2067                    }
2068            }   
2069            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2070            lowlevel::Response::Success { name: String::from("TESTOL"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2071        },
2072        highlevel::Success::Testm {
2073            field,
2074        } => {
2075            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2076            for (field_typed_key, field_typed_value) in field {
2077                let field_primitive_key = i64::to_string(&field_typed_key);
2078                let field_primitive_value = field_typed_value.clone();
2079                let field_untyped_pair = lowlevel::Argument::KeyValueArgument { key: field_primitive_key, value: field_primitive_value };
2080                raw_arguments.push(field_untyped_pair);
2081            }   
2082            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2083            lowlevel::Response::Success { name: String::from("TESTM"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2084        },
2085        highlevel::Success::Testp {
2086            field,
2087        } => {
2088            let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
2089            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2090            let field_string = i64::to_string(&field);
2091            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
2092            raw_arguments_inner.push(field_primitive);
2093            raw_arguments_outer.push(raw_arguments_inner);
2094            let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
2095            lowlevel::Response::Success { name: String::from("TESTP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2096        },
2097        highlevel::Success::Testpp {
2098            field1,
2099            field2,
2100            field3,
2101        } => {
2102            let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
2103            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2104            let field1_string = i64::to_string(&field1);
2105            let field1_primitive = lowlevel::Argument::PrimitiveArgument(field1_string);
2106            raw_arguments_inner.push(field1_primitive);
2107            raw_arguments_outer.push(raw_arguments_inner);
2108            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2109            let field2_string = i64::to_string(&field2);
2110            let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
2111            raw_arguments_inner.push(field2_primitive);
2112            let field3_string = field3.clone();
2113            let field3_primitive = lowlevel::Argument::PrimitiveArgument(field3_string);
2114            raw_arguments_inner.push(field3_primitive);
2115            raw_arguments_outer.push(raw_arguments_inner);
2116            let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
2117            lowlevel::Response::Success { name: String::from("TESTPP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2118        },
2119        highlevel::Success::Testpmpil {
2120            field1,
2121            field2,
2122            field3,
2123        } => {
2124            let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
2125            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2126            for (field1_typed_key, field1_typed_value) in field1 {
2127                let field1_primitive_key = i64::to_string(&field1_typed_key);
2128                let field1_primitive_value = field1_typed_value.clone();
2129                let field1_untyped_pair = lowlevel::Argument::KeyValueArgument { key: field1_primitive_key, value: field1_primitive_value };
2130                raw_arguments_inner.push(field1_untyped_pair);
2131            }   
2132            raw_arguments_outer.push(raw_arguments_inner);
2133            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2134            let field2_string = i64::to_string(&field2);
2135            let field2_primitive = lowlevel::Argument::PrimitiveArgument(field2_string);
2136            raw_arguments_inner.push(field2_primitive);
2137            for field3_element in field3.into_iter() {
2138                    let field3_element_string = i64::to_string(&field3_element);
2139                    let field3_element_primitive = lowlevel::Argument::PrimitiveArgument(field3_element_string);
2140                    raw_arguments_inner.push(field3_element_primitive);
2141            }   
2142            raw_arguments_outer.push(raw_arguments_inner);
2143            let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
2144            lowlevel::Response::Success { name: String::from("TESTPMPIL"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2145        },
2146        highlevel::Success::SameOne {
2147            field,
2148        } => {
2149            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2150            let field_string = i64::to_string(&field);
2151            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
2152            raw_arguments.push(field_primitive);
2153            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2154            lowlevel::Response::Success { name: String::from("SAME"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2155        },
2156        highlevel::Success::SameTwo {
2157            field,
2158        } => {
2159            let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
2160            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2161            let field_string = i64::to_string(&field);
2162            let field_primitive = lowlevel::Argument::PrimitiveArgument(field_string);
2163            raw_arguments_inner.push(field_primitive);
2164            raw_arguments_outer.push(raw_arguments_inner);
2165            let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
2166            lowlevel::Response::Success { name: String::from("SAME"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2167        },
2168        highlevel::Success::Brsf {
2169            features,
2170        } => {
2171            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2172            let features_string = i64::to_string(&features);
2173            let features_primitive = lowlevel::Argument::PrimitiveArgument(features_string);
2174            raw_arguments.push(features_primitive);
2175            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2176            lowlevel::Response::Success { name: String::from("BRSF"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2177        },
2178        highlevel::Success::CindRead {
2179            ordered_values,
2180        } => {
2181            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2182            for ordered_values_element in ordered_values.into_iter() {
2183                    let ordered_values_element_string = i64::to_string(&ordered_values_element);
2184                    let ordered_values_element_primitive = lowlevel::Argument::PrimitiveArgument(ordered_values_element_string);
2185                    raw_arguments.push(ordered_values_element_primitive);
2186            }   
2187            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2188            lowlevel::Response::Success { name: String::from("CIND"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2189        },
2190        highlevel::Success::Clcc {
2191            index,
2192            dir,
2193            status,
2194            mode,
2195            mpty,
2196            number,
2197            ty,
2198        } => {
2199            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2200            let index_string = i64::to_string(&index);
2201            let index_primitive = lowlevel::Argument::PrimitiveArgument(index_string);
2202            raw_arguments.push(index_primitive);
2203            let dir_string = i64::to_string(&dir);
2204            let dir_primitive = lowlevel::Argument::PrimitiveArgument(dir_string);
2205            raw_arguments.push(dir_primitive);
2206            let status_string = i64::to_string(&status);
2207            let status_primitive = lowlevel::Argument::PrimitiveArgument(status_string);
2208            raw_arguments.push(status_primitive);
2209            let mode_string = i64::to_string(&mode);
2210            let mode_primitive = lowlevel::Argument::PrimitiveArgument(mode_string);
2211            raw_arguments.push(mode_primitive);
2212            let mpty_string = i64::to_string(&mpty);
2213            let mpty_primitive = lowlevel::Argument::PrimitiveArgument(mpty_string);
2214            raw_arguments.push(mpty_primitive);
2215            let number_string = number.clone();
2216            let number_primitive = lowlevel::Argument::PrimitiveArgument(number_string);
2217            raw_arguments.push(number_primitive);
2218            let ty_string = i64::to_string(&ty);
2219            let ty_primitive = lowlevel::Argument::PrimitiveArgument(ty_string);
2220            raw_arguments.push(ty_primitive);
2221            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2222            lowlevel::Response::Success { name: String::from("CLCC"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2223        },
2224        highlevel::Success::Bcs {
2225            codec,
2226        } => {
2227            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2228            let codec_string = i64::to_string(&codec);
2229            let codec_primitive = lowlevel::Argument::PrimitiveArgument(codec_string);
2230            raw_arguments.push(codec_primitive);
2231            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2232            lowlevel::Response::Success { name: String::from("BCS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2233        },
2234        highlevel::Success::BindList {
2235            indicators,
2236        } => {
2237            let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
2238            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2239            for indicators_element in indicators.into_iter() {
2240                    let indicators_element_string_int = *indicators_element as i64;
2241                    let indicators_element_string = i64::to_string(&indicators_element_string_int);
2242                    let indicators_element_primitive = lowlevel::Argument::PrimitiveArgument(indicators_element_string);
2243                    raw_arguments_inner.push(indicators_element_primitive);
2244            }   
2245            raw_arguments_outer.push(raw_arguments_inner);
2246            let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
2247            lowlevel::Response::Success { name: String::from("BIND"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2248        },
2249        highlevel::Success::BindStatus {
2250            anum,
2251            state,
2252        } => {
2253            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2254            let anum_string_int = *anum as i64;
2255            let anum_string = i64::to_string(&anum_string_int);
2256            let anum_primitive = lowlevel::Argument::PrimitiveArgument(anum_string);
2257            raw_arguments.push(anum_primitive);
2258            let state_string_int = if *state { 1 } else { 0 };
2259            let state_string = i64::to_string(&state_string_int);
2260            let state_primitive = lowlevel::Argument::PrimitiveArgument(state_string);
2261            raw_arguments.push(state_primitive);
2262            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2263            lowlevel::Response::Success { name: String::from("BIND"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2264        },
2265        highlevel::Success::Chld {
2266            commands,
2267        } => {
2268            let mut raw_arguments_outer = Vec::<Vec<lowlevel::Argument>>::new();
2269            let mut raw_arguments_inner = Vec::<lowlevel::Argument>::new();
2270            for commands_element in commands.into_iter() {
2271                    let commands_element_string = commands_element.clone();
2272                    let commands_element_primitive = lowlevel::Argument::PrimitiveArgument(commands_element_string);
2273                    raw_arguments_inner.push(commands_element_primitive);
2274            }   
2275            raw_arguments_outer.push(raw_arguments_inner);
2276            let arguments = lowlevel::Arguments::ParenthesisDelimitedArgumentLists(raw_arguments_outer);
2277            lowlevel::Response::Success { name: String::from("CHLD"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2278        },
2279        highlevel::Success::Cops {
2280            format,
2281            zero,
2282            operator,
2283        } => {
2284            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2285            let format_string_int = *format as i64;
2286            let format_string = i64::to_string(&format_string_int);
2287            let format_primitive = lowlevel::Argument::PrimitiveArgument(format_string);
2288            raw_arguments.push(format_primitive);
2289            let zero_string = i64::to_string(&zero);
2290            let zero_primitive = lowlevel::Argument::PrimitiveArgument(zero_string);
2291            raw_arguments.push(zero_primitive);
2292            let operator_string = operator.clone();
2293            let operator_primitive = lowlevel::Argument::PrimitiveArgument(operator_string);
2294            raw_arguments.push(operator_primitive);
2295            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2296            lowlevel::Response::Success { name: String::from("COPS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2297        },
2298        highlevel::Success::Clip {
2299            number,
2300            ty,
2301        } => {
2302            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2303            let number_string = number.clone();
2304            let number_primitive = lowlevel::Argument::PrimitiveArgument(number_string);
2305            raw_arguments.push(number_primitive);
2306            let ty_string = i64::to_string(&ty);
2307            let ty_primitive = lowlevel::Argument::PrimitiveArgument(ty_string);
2308            raw_arguments.push(ty_primitive);
2309            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2310            lowlevel::Response::Success { name: String::from("CLIP"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2311        },
2312        highlevel::Success::Cnum {
2313            alpha,
2314            number,
2315            ty,
2316            speed,
2317            service,
2318        } => {
2319            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2320            let alpha_string = alpha.clone();
2321            let alpha_primitive = lowlevel::Argument::PrimitiveArgument(alpha_string);
2322            raw_arguments.push(alpha_primitive);
2323            let number_string = number.clone();
2324            let number_primitive = lowlevel::Argument::PrimitiveArgument(number_string);
2325            raw_arguments.push(number_primitive);
2326            let ty_string = i64::to_string(&ty);
2327            let ty_primitive = lowlevel::Argument::PrimitiveArgument(ty_string);
2328            raw_arguments.push(ty_primitive);
2329            let speed_string = speed.clone();
2330            let speed_primitive = lowlevel::Argument::PrimitiveArgument(speed_string);
2331            raw_arguments.push(speed_primitive);
2332            let service_string = i64::to_string(&service);
2333            let service_primitive = lowlevel::Argument::PrimitiveArgument(service_string);
2334            raw_arguments.push(service_primitive);
2335            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2336            lowlevel::Response::Success { name: String::from("CNUM"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2337        },
2338        highlevel::Success::Vgs {
2339            level,
2340        } => {
2341            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2342            let level_string = i64::to_string(&level);
2343            let level_primitive = lowlevel::Argument::PrimitiveArgument(level_string);
2344            raw_arguments.push(level_primitive);
2345            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2346            lowlevel::Response::Success { name: String::from("VGS"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2347        },
2348        highlevel::Success::Vgm {
2349            level,
2350        } => {
2351            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2352            let level_string = i64::to_string(&level);
2353            let level_primitive = lowlevel::Argument::PrimitiveArgument(level_string);
2354            raw_arguments.push(level_primitive);
2355            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2356            lowlevel::Response::Success { name: String::from("VGM"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2357        },
2358        highlevel::Success::Ciev {
2359            ind,
2360            value,
2361        } => {
2362            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2363            let ind_string = i64::to_string(&ind);
2364            let ind_primitive = lowlevel::Argument::PrimitiveArgument(ind_string);
2365            raw_arguments.push(ind_primitive);
2366            let value_string = i64::to_string(&value);
2367            let value_primitive = lowlevel::Argument::PrimitiveArgument(value_string);
2368            raw_arguments.push(value_primitive);
2369            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2370            lowlevel::Response::Success { name: String::from("CIEV"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2371        },
2372        highlevel::Success::Ccwa {
2373            number,
2374            ty,
2375        } => {
2376            let mut raw_arguments = Vec::<lowlevel::Argument>::new();
2377            let number_string = number.clone();
2378            let number_primitive = lowlevel::Argument::PrimitiveArgument(number_string);
2379            raw_arguments.push(number_primitive);
2380            let ty_string = i64::to_string(&ty);
2381            let ty_primitive = lowlevel::Argument::PrimitiveArgument(ty_string);
2382            raw_arguments.push(ty_primitive);
2383            let arguments = lowlevel::Arguments::ArgumentList(raw_arguments);
2384            lowlevel::Response::Success { name: String::from("CCWA"), is_extension: true, arguments: lowlevel::DelimitedArguments { delimiter: Some(String::from(":")), arguments, terminator: None } }
2385        },
2386        highlevel::Success::Ring {        } => {
2387            let arguments = lowlevel::Arguments::ArgumentList(Vec::new());
2388            lowlevel::Response::Success { name: String::from("RING"), is_extension: false, arguments: lowlevel::DelimitedArguments { delimiter: None, arguments, terminator: None } }
2389        },
2390    }
2391}
2392