1#![allow(
5 unused_imports,
6 clippy::large_enum_variant,
7 clippy::too_many_lines,
8 clippy::doc_markdown
9)]
10
11use crate::decode::{
12 choice_key, required, required_list, resource_type, Choice, Decoder, FhirJson, Obj, ObjWriter,
13};
14use crate::json::Json;
15use crate::primitive::{Decimal, Kind, Primitive};
16use crate::r4::*;
17
18#[cfg(feature = "specialized")]
22#[derive(Debug, Clone, PartialEq, Default)]
23pub struct TestReport {
24 pub id: Option<String>,
26 pub meta: Option<Meta>,
28 pub implicit_rules: Option<Primitive<String>>,
30 pub language: Option<Primitive<String>>,
32 pub text: Option<Narrative>,
34 pub contained: Vec<Resource>,
36 pub extension: Vec<Extension>,
38 pub modifier_extension: Vec<Extension>,
40 pub identifier: Option<Identifier>,
42 pub name: Option<Primitive<String>>,
44 pub status: Option<Primitive<String>>,
46 pub test_script: Option<Reference>,
48 pub result: Option<Primitive<String>>,
50 pub score: Option<Primitive<Decimal>>,
52 pub tester: Option<Primitive<String>>,
54 pub issued: Option<Primitive<String>>,
56 pub participant: Vec<TestReportParticipant>,
58 pub setup: Option<TestReportSetup>,
60 pub test: Vec<TestReportTest>,
62 pub teardown: Option<TestReportTeardown>,
64}
65
66#[cfg(feature = "specialized")]
67impl FhirJson for TestReport {
68 const TYPE_NAME: &'static str = "TestReport";
69
70 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
71 let mut o = Obj::new(v, d)?;
72 resource_type(&mut o, d, "TestReport");
73 let r = TestReport {
74 id: o.string(d, "id"),
75 meta: o.one(d, "meta"),
76 implicit_rules: o.prim(d, "implicitRules", Kind::Uri),
77 language: o.prim(d, "language", Kind::Code),
78 text: o.one(d, "text"),
79 contained: o.list(d, "contained"),
80 extension: o.list(d, "extension"),
81 modifier_extension: o.list(d, "modifierExtension"),
82 identifier: o.one(d, "identifier"),
83 name: o.prim(d, "name", Kind::String),
84 status: o.prim(d, "status", Kind::Code),
85 test_script: o.one(d, "testScript"),
86 result: o.prim(d, "result", Kind::Code),
87 score: o.prim(d, "score", Kind::Decimal),
88 tester: o.prim(d, "tester", Kind::String),
89 issued: o.prim(d, "issued", Kind::DateTime),
90 participant: o.list(d, "participant"),
91 setup: o.one(d, "setup"),
92 test: o.list(d, "test"),
93 teardown: o.one(d, "teardown"),
94 };
95 required(d, "status", &r.status);
96 required(d, "testScript", &r.test_script);
97 required(d, "result", &r.result);
98 o.finish(d);
99 Some(r)
100 }
101
102 fn encode(&self) -> Json {
103 let mut w = ObjWriter::new();
104 w.raw("resourceType", Json::String("TestReport".into()));
105 w.string("id", &self.id);
106 w.one("meta", &self.meta);
107 w.prim("implicitRules", &self.implicit_rules);
108 w.prim("language", &self.language);
109 w.one("text", &self.text);
110 w.list("contained", &self.contained);
111 w.list("extension", &self.extension);
112 w.list("modifierExtension", &self.modifier_extension);
113 w.one("identifier", &self.identifier);
114 w.prim("name", &self.name);
115 w.prim("status", &self.status);
116 w.one("testScript", &self.test_script);
117 w.prim("result", &self.result);
118 w.prim("score", &self.score);
119 w.prim("tester", &self.tester);
120 w.prim("issued", &self.issued);
121 w.list("participant", &self.participant);
122 w.one("setup", &self.setup);
123 w.list("test", &self.test);
124 w.one("teardown", &self.teardown);
125 w.finish()
126 }
127}
128
129#[cfg(feature = "specialized")]
133#[derive(Debug, Clone, PartialEq, Default)]
134pub struct TestReportParticipant {
135 pub id: Option<String>,
137 pub extension: Vec<Extension>,
139 pub modifier_extension: Vec<Extension>,
141 pub type_: Option<Primitive<String>>,
143 pub uri: Option<Primitive<String>>,
145 pub display: Option<Primitive<String>>,
147}
148
149#[cfg(feature = "specialized")]
150impl FhirJson for TestReportParticipant {
151 const TYPE_NAME: &'static str = "TestReportParticipant";
152
153 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
154 let mut o = Obj::new(v, d)?;
155 let r = TestReportParticipant {
156 id: o.string(d, "id"),
157 extension: o.list(d, "extension"),
158 modifier_extension: o.list(d, "modifierExtension"),
159 type_: o.prim(d, "type", Kind::Code),
160 uri: o.prim(d, "uri", Kind::Uri),
161 display: o.prim(d, "display", Kind::String),
162 };
163 required(d, "type", &r.type_);
164 required(d, "uri", &r.uri);
165 o.finish(d);
166 Some(r)
167 }
168
169 fn encode(&self) -> Json {
170 let mut w = ObjWriter::new();
171 w.string("id", &self.id);
172 w.list("extension", &self.extension);
173 w.list("modifierExtension", &self.modifier_extension);
174 w.prim("type", &self.type_);
175 w.prim("uri", &self.uri);
176 w.prim("display", &self.display);
177 w.finish()
178 }
179}
180
181#[cfg(feature = "specialized")]
185#[derive(Debug, Clone, PartialEq, Default)]
186pub struct TestReportSetup {
187 pub id: Option<String>,
189 pub extension: Vec<Extension>,
191 pub modifier_extension: Vec<Extension>,
193 pub action: Vec<TestReportSetupAction>,
195}
196
197#[cfg(feature = "specialized")]
198impl FhirJson for TestReportSetup {
199 const TYPE_NAME: &'static str = "TestReportSetup";
200
201 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
202 let mut o = Obj::new(v, d)?;
203 let r = TestReportSetup {
204 id: o.string(d, "id"),
205 extension: o.list(d, "extension"),
206 modifier_extension: o.list(d, "modifierExtension"),
207 action: o.list(d, "action"),
208 };
209 required_list(d, "action", &r.action, 1);
210 o.finish(d);
211 Some(r)
212 }
213
214 fn encode(&self) -> Json {
215 let mut w = ObjWriter::new();
216 w.string("id", &self.id);
217 w.list("extension", &self.extension);
218 w.list("modifierExtension", &self.modifier_extension);
219 w.list("action", &self.action);
220 w.finish()
221 }
222}
223
224#[cfg(feature = "specialized")]
228#[derive(Debug, Clone, PartialEq, Default)]
229pub struct TestReportSetupAction {
230 pub id: Option<String>,
232 pub extension: Vec<Extension>,
234 pub modifier_extension: Vec<Extension>,
236 pub operation: Option<TestReportSetupActionOperation>,
238 pub assert: Option<TestReportSetupActionAssert>,
240}
241
242#[cfg(feature = "specialized")]
243impl FhirJson for TestReportSetupAction {
244 const TYPE_NAME: &'static str = "TestReportSetupAction";
245
246 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
247 let mut o = Obj::new(v, d)?;
248 let r = TestReportSetupAction {
249 id: o.string(d, "id"),
250 extension: o.list(d, "extension"),
251 modifier_extension: o.list(d, "modifierExtension"),
252 operation: o.one(d, "operation"),
253 assert: o.one(d, "assert"),
254 };
255 o.finish(d);
256 Some(r)
257 }
258
259 fn encode(&self) -> Json {
260 let mut w = ObjWriter::new();
261 w.string("id", &self.id);
262 w.list("extension", &self.extension);
263 w.list("modifierExtension", &self.modifier_extension);
264 w.one("operation", &self.operation);
265 w.one("assert", &self.assert);
266 w.finish()
267 }
268}
269
270#[cfg(feature = "specialized")]
274#[derive(Debug, Clone, PartialEq, Default)]
275pub struct TestReportSetupActionOperation {
276 pub id: Option<String>,
278 pub extension: Vec<Extension>,
280 pub modifier_extension: Vec<Extension>,
282 pub result: Option<Primitive<String>>,
284 pub message: Option<Primitive<String>>,
286 pub detail: Option<Primitive<String>>,
288}
289
290#[cfg(feature = "specialized")]
291impl FhirJson for TestReportSetupActionOperation {
292 const TYPE_NAME: &'static str = "TestReportSetupActionOperation";
293
294 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
295 let mut o = Obj::new(v, d)?;
296 let r = TestReportSetupActionOperation {
297 id: o.string(d, "id"),
298 extension: o.list(d, "extension"),
299 modifier_extension: o.list(d, "modifierExtension"),
300 result: o.prim(d, "result", Kind::Code),
301 message: o.prim(d, "message", Kind::Markdown),
302 detail: o.prim(d, "detail", Kind::Uri),
303 };
304 required(d, "result", &r.result);
305 o.finish(d);
306 Some(r)
307 }
308
309 fn encode(&self) -> Json {
310 let mut w = ObjWriter::new();
311 w.string("id", &self.id);
312 w.list("extension", &self.extension);
313 w.list("modifierExtension", &self.modifier_extension);
314 w.prim("result", &self.result);
315 w.prim("message", &self.message);
316 w.prim("detail", &self.detail);
317 w.finish()
318 }
319}
320
321#[cfg(feature = "specialized")]
325#[derive(Debug, Clone, PartialEq, Default)]
326pub struct TestReportSetupActionAssert {
327 pub id: Option<String>,
329 pub extension: Vec<Extension>,
331 pub modifier_extension: Vec<Extension>,
333 pub result: Option<Primitive<String>>,
335 pub message: Option<Primitive<String>>,
337 pub detail: Option<Primitive<String>>,
339}
340
341#[cfg(feature = "specialized")]
342impl FhirJson for TestReportSetupActionAssert {
343 const TYPE_NAME: &'static str = "TestReportSetupActionAssert";
344
345 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
346 let mut o = Obj::new(v, d)?;
347 let r = TestReportSetupActionAssert {
348 id: o.string(d, "id"),
349 extension: o.list(d, "extension"),
350 modifier_extension: o.list(d, "modifierExtension"),
351 result: o.prim(d, "result", Kind::Code),
352 message: o.prim(d, "message", Kind::Markdown),
353 detail: o.prim(d, "detail", Kind::String),
354 };
355 required(d, "result", &r.result);
356 o.finish(d);
357 Some(r)
358 }
359
360 fn encode(&self) -> Json {
361 let mut w = ObjWriter::new();
362 w.string("id", &self.id);
363 w.list("extension", &self.extension);
364 w.list("modifierExtension", &self.modifier_extension);
365 w.prim("result", &self.result);
366 w.prim("message", &self.message);
367 w.prim("detail", &self.detail);
368 w.finish()
369 }
370}
371
372#[cfg(feature = "specialized")]
376#[derive(Debug, Clone, PartialEq, Default)]
377pub struct TestReportTest {
378 pub id: Option<String>,
380 pub extension: Vec<Extension>,
382 pub modifier_extension: Vec<Extension>,
384 pub name: Option<Primitive<String>>,
386 pub description: Option<Primitive<String>>,
388 pub action: Vec<TestReportTestAction>,
390}
391
392#[cfg(feature = "specialized")]
393impl FhirJson for TestReportTest {
394 const TYPE_NAME: &'static str = "TestReportTest";
395
396 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
397 let mut o = Obj::new(v, d)?;
398 let r = TestReportTest {
399 id: o.string(d, "id"),
400 extension: o.list(d, "extension"),
401 modifier_extension: o.list(d, "modifierExtension"),
402 name: o.prim(d, "name", Kind::String),
403 description: o.prim(d, "description", Kind::String),
404 action: o.list(d, "action"),
405 };
406 required_list(d, "action", &r.action, 1);
407 o.finish(d);
408 Some(r)
409 }
410
411 fn encode(&self) -> Json {
412 let mut w = ObjWriter::new();
413 w.string("id", &self.id);
414 w.list("extension", &self.extension);
415 w.list("modifierExtension", &self.modifier_extension);
416 w.prim("name", &self.name);
417 w.prim("description", &self.description);
418 w.list("action", &self.action);
419 w.finish()
420 }
421}
422
423#[cfg(feature = "specialized")]
427#[derive(Debug, Clone, PartialEq, Default)]
428pub struct TestReportTestAction {
429 pub id: Option<String>,
431 pub extension: Vec<Extension>,
433 pub modifier_extension: Vec<Extension>,
435 pub operation: Option<TestReportSetupActionOperation>,
437 pub assert: Option<TestReportSetupActionAssert>,
439}
440
441#[cfg(feature = "specialized")]
442impl FhirJson for TestReportTestAction {
443 const TYPE_NAME: &'static str = "TestReportTestAction";
444
445 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
446 let mut o = Obj::new(v, d)?;
447 let r = TestReportTestAction {
448 id: o.string(d, "id"),
449 extension: o.list(d, "extension"),
450 modifier_extension: o.list(d, "modifierExtension"),
451 operation: o.one(d, "operation"),
452 assert: o.one(d, "assert"),
453 };
454 o.finish(d);
455 Some(r)
456 }
457
458 fn encode(&self) -> Json {
459 let mut w = ObjWriter::new();
460 w.string("id", &self.id);
461 w.list("extension", &self.extension);
462 w.list("modifierExtension", &self.modifier_extension);
463 w.one("operation", &self.operation);
464 w.one("assert", &self.assert);
465 w.finish()
466 }
467}
468
469#[cfg(feature = "specialized")]
473#[derive(Debug, Clone, PartialEq, Default)]
474pub struct TestReportTeardown {
475 pub id: Option<String>,
477 pub extension: Vec<Extension>,
479 pub modifier_extension: Vec<Extension>,
481 pub action: Vec<TestReportTeardownAction>,
483}
484
485#[cfg(feature = "specialized")]
486impl FhirJson for TestReportTeardown {
487 const TYPE_NAME: &'static str = "TestReportTeardown";
488
489 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
490 let mut o = Obj::new(v, d)?;
491 let r = TestReportTeardown {
492 id: o.string(d, "id"),
493 extension: o.list(d, "extension"),
494 modifier_extension: o.list(d, "modifierExtension"),
495 action: o.list(d, "action"),
496 };
497 required_list(d, "action", &r.action, 1);
498 o.finish(d);
499 Some(r)
500 }
501
502 fn encode(&self) -> Json {
503 let mut w = ObjWriter::new();
504 w.string("id", &self.id);
505 w.list("extension", &self.extension);
506 w.list("modifierExtension", &self.modifier_extension);
507 w.list("action", &self.action);
508 w.finish()
509 }
510}
511
512#[cfg(feature = "specialized")]
516#[derive(Debug, Clone, PartialEq, Default)]
517pub struct TestReportTeardownAction {
518 pub id: Option<String>,
520 pub extension: Vec<Extension>,
522 pub modifier_extension: Vec<Extension>,
524 pub operation: Option<TestReportSetupActionOperation>,
526}
527
528#[cfg(feature = "specialized")]
529impl FhirJson for TestReportTeardownAction {
530 const TYPE_NAME: &'static str = "TestReportTeardownAction";
531
532 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
533 let mut o = Obj::new(v, d)?;
534 let r = TestReportTeardownAction {
535 id: o.string(d, "id"),
536 extension: o.list(d, "extension"),
537 modifier_extension: o.list(d, "modifierExtension"),
538 operation: o.one(d, "operation"),
539 };
540 required(d, "operation", &r.operation);
541 o.finish(d);
542 Some(r)
543 }
544
545 fn encode(&self) -> Json {
546 let mut w = ObjWriter::new();
547 w.string("id", &self.id);
548 w.list("extension", &self.extension);
549 w.list("modifierExtension", &self.modifier_extension);
550 w.one("operation", &self.operation);
551 w.finish()
552 }
553}