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 MedicinalProductAuthorization {
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: Vec<Identifier>,
42 pub subject: Option<Reference>,
44 pub country: Vec<CodeableConcept>,
46 pub jurisdiction: Vec<CodeableConcept>,
48 pub status: Option<CodeableConcept>,
50 pub status_date: Option<Primitive<String>>,
52 pub restore_date: Option<Primitive<String>>,
54 pub validity_period: Option<Period>,
56 pub data_exclusivity_period: Option<Period>,
58 pub date_of_first_authorization: Option<Primitive<String>>,
60 pub international_birth_date: Option<Primitive<String>>,
62 pub legal_basis: Option<CodeableConcept>,
64 pub jurisdictional_authorization: Vec<MedicinalProductAuthorizationJurisdictionalAuthorization>,
66 pub holder: Option<Reference>,
68 pub regulator: Option<Reference>,
70 pub procedure: Option<MedicinalProductAuthorizationProcedure>,
72}
73
74#[cfg(feature = "specialized")]
75impl FhirJson for MedicinalProductAuthorization {
76 const TYPE_NAME: &'static str = "MedicinalProductAuthorization";
77
78 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
79 let mut o = Obj::new(v, d)?;
80 resource_type(&mut o, d, "MedicinalProductAuthorization");
81 let r = MedicinalProductAuthorization {
82 id: o.string(d, "id"),
83 meta: o.one(d, "meta"),
84 implicit_rules: o.prim(d, "implicitRules", Kind::Uri),
85 language: o.prim(d, "language", Kind::Code),
86 text: o.one(d, "text"),
87 contained: o.list(d, "contained"),
88 extension: o.list(d, "extension"),
89 modifier_extension: o.list(d, "modifierExtension"),
90 identifier: o.list(d, "identifier"),
91 subject: o.one(d, "subject"),
92 country: o.list(d, "country"),
93 jurisdiction: o.list(d, "jurisdiction"),
94 status: o.one(d, "status"),
95 status_date: o.prim(d, "statusDate", Kind::DateTime),
96 restore_date: o.prim(d, "restoreDate", Kind::DateTime),
97 validity_period: o.one(d, "validityPeriod"),
98 data_exclusivity_period: o.one(d, "dataExclusivityPeriod"),
99 date_of_first_authorization: o.prim(d, "dateOfFirstAuthorization", Kind::DateTime),
100 international_birth_date: o.prim(d, "internationalBirthDate", Kind::DateTime),
101 legal_basis: o.one(d, "legalBasis"),
102 jurisdictional_authorization: o.list(d, "jurisdictionalAuthorization"),
103 holder: o.one(d, "holder"),
104 regulator: o.one(d, "regulator"),
105 procedure: o.one(d, "procedure"),
106 };
107 o.finish(d);
108 Some(r)
109 }
110
111 fn encode(&self) -> Json {
112 let mut w = ObjWriter::new();
113 w.raw(
114 "resourceType",
115 Json::String("MedicinalProductAuthorization".into()),
116 );
117 w.string("id", &self.id);
118 w.one("meta", &self.meta);
119 w.prim("implicitRules", &self.implicit_rules);
120 w.prim("language", &self.language);
121 w.one("text", &self.text);
122 w.list("contained", &self.contained);
123 w.list("extension", &self.extension);
124 w.list("modifierExtension", &self.modifier_extension);
125 w.list("identifier", &self.identifier);
126 w.one("subject", &self.subject);
127 w.list("country", &self.country);
128 w.list("jurisdiction", &self.jurisdiction);
129 w.one("status", &self.status);
130 w.prim("statusDate", &self.status_date);
131 w.prim("restoreDate", &self.restore_date);
132 w.one("validityPeriod", &self.validity_period);
133 w.one("dataExclusivityPeriod", &self.data_exclusivity_period);
134 w.prim(
135 "dateOfFirstAuthorization",
136 &self.date_of_first_authorization,
137 );
138 w.prim("internationalBirthDate", &self.international_birth_date);
139 w.one("legalBasis", &self.legal_basis);
140 w.list(
141 "jurisdictionalAuthorization",
142 &self.jurisdictional_authorization,
143 );
144 w.one("holder", &self.holder);
145 w.one("regulator", &self.regulator);
146 w.one("procedure", &self.procedure);
147 w.finish()
148 }
149}
150
151#[cfg(feature = "specialized")]
155#[derive(Debug, Clone, PartialEq, Default)]
156pub struct MedicinalProductAuthorizationJurisdictionalAuthorization {
157 pub id: Option<String>,
159 pub extension: Vec<Extension>,
161 pub modifier_extension: Vec<Extension>,
163 pub identifier: Vec<Identifier>,
165 pub country: Option<CodeableConcept>,
167 pub jurisdiction: Vec<CodeableConcept>,
169 pub legal_status_of_supply: Option<CodeableConcept>,
171 pub validity_period: Option<Period>,
173}
174
175#[cfg(feature = "specialized")]
176impl FhirJson for MedicinalProductAuthorizationJurisdictionalAuthorization {
177 const TYPE_NAME: &'static str = "MedicinalProductAuthorizationJurisdictionalAuthorization";
178
179 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
180 let mut o = Obj::new(v, d)?;
181 let r = MedicinalProductAuthorizationJurisdictionalAuthorization {
182 id: o.string(d, "id"),
183 extension: o.list(d, "extension"),
184 modifier_extension: o.list(d, "modifierExtension"),
185 identifier: o.list(d, "identifier"),
186 country: o.one(d, "country"),
187 jurisdiction: o.list(d, "jurisdiction"),
188 legal_status_of_supply: o.one(d, "legalStatusOfSupply"),
189 validity_period: o.one(d, "validityPeriod"),
190 };
191 o.finish(d);
192 Some(r)
193 }
194
195 fn encode(&self) -> Json {
196 let mut w = ObjWriter::new();
197 w.string("id", &self.id);
198 w.list("extension", &self.extension);
199 w.list("modifierExtension", &self.modifier_extension);
200 w.list("identifier", &self.identifier);
201 w.one("country", &self.country);
202 w.list("jurisdiction", &self.jurisdiction);
203 w.one("legalStatusOfSupply", &self.legal_status_of_supply);
204 w.one("validityPeriod", &self.validity_period);
205 w.finish()
206 }
207}
208
209#[cfg(feature = "specialized")]
213#[derive(Debug, Clone, PartialEq, Default)]
214pub struct MedicinalProductAuthorizationProcedure {
215 pub id: Option<String>,
217 pub extension: Vec<Extension>,
219 pub modifier_extension: Vec<Extension>,
221 pub identifier: Option<Identifier>,
223 pub type_: Option<CodeableConcept>,
225 pub date: Option<MedicinalProductAuthorizationProcedureDate>,
227 pub application: Vec<MedicinalProductAuthorizationProcedure>,
229}
230
231#[cfg(feature = "specialized")]
232impl FhirJson for MedicinalProductAuthorizationProcedure {
233 const TYPE_NAME: &'static str = "MedicinalProductAuthorizationProcedure";
234
235 fn decode(v: &Json, d: &mut Decoder) -> Option<Self> {
236 let mut o = Obj::new(v, d)?;
237 let r = MedicinalProductAuthorizationProcedure {
238 id: o.string(d, "id"),
239 extension: o.list(d, "extension"),
240 modifier_extension: o.list(d, "modifierExtension"),
241 identifier: o.one(d, "identifier"),
242 type_: o.one(d, "type"),
243 date: o.choice(d, "date"),
244 application: o.list(d, "application"),
245 };
246 required(d, "type", &r.type_);
247 o.finish(d);
248 Some(r)
249 }
250
251 fn encode(&self) -> Json {
252 let mut w = ObjWriter::new();
253 w.string("id", &self.id);
254 w.list("extension", &self.extension);
255 w.list("modifierExtension", &self.modifier_extension);
256 w.one("identifier", &self.identifier);
257 w.one("type", &self.type_);
258 w.choice("date", &self.date);
259 w.list("application", &self.application);
260 w.finish()
261 }
262}
263
264#[cfg(feature = "specialized")]
266#[derive(Debug, Clone, PartialEq)]
267pub enum MedicinalProductAuthorizationProcedureDate {
268 Period(Period),
270 DateTime(Primitive<String>),
272}
273
274#[cfg(feature = "specialized")]
275impl Choice for MedicinalProductAuthorizationProcedureDate {
276 const TYPES: &'static [&'static str] = &["Period", "dateTime"];
277
278 fn decode_as(code: &str, key: &str, o: &mut Obj<'_>, d: &mut Decoder) -> Option<Self> {
279 match code {
280 "Period" => o.one(d, key).map(Self::Period),
281 "dateTime" => o.prim(d, key, Kind::DateTime).map(Self::DateTime),
282 _ => None,
283 }
284 }
285
286 fn encode_into(&self, base: &str, w: &mut ObjWriter) {
287 match self {
288 Self::Period(v) => w.value(&choice_key(base, "Period"), v),
289 Self::DateTime(v) => w.prim_value(&choice_key(base, "dateTime"), v),
290 }
291 }
292}