1#![allow(non_snake_case)]
5
6use serde::{Deserialize, Serialize};
7
8#[derive(Debug, Clone, Serialize, Deserialize, Default)]
9pub struct AdditionalInfo {
10 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
11 pub item_name: Option<String>,
12 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
14 default, deserialize_with = "crate::schema::serde_flex::flex_vec_string_opt")]
15 pub full_text: Option<Vec<String>>,
16}
17
18#[derive(Debug, Clone, Serialize, Deserialize, Default)]
19pub struct NumericRangeWithUnitAndQualifier {
20 #[serde(rename = "ExactValue", skip_serializing_if = "Option::is_none")]
21 pub exact_value: Option<NumericRangeWithUnitAndQualifierExactValue>,
22 #[serde(rename = "UpperValue", skip_serializing_if = "Option::is_none")]
23 pub upper_value: Option<NumericRangeWithUnitAndQualifierUpperValue>,
24 #[serde(rename = "LowerValue", skip_serializing_if = "Option::is_none")]
25 pub lower_value: Option<NumericRangeWithUnitAndQualifierLowerValue>,
26 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
27 pub unit: Option<String>,
28 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
29 pub additional_info: Option<AdditionalInfo>,
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize, Default)]
33pub struct NumericRangeWithUnitAndQualifierExactValue {
34 #[serde(rename = "ValueSymbol", skip_serializing_if = "Option::is_none")]
35 pub value_symbol: Option<String>,
36 #[serde(rename = "Value", skip_serializing_if = "Option::is_none")]
37 pub value: Option<f64>,
38}
39
40#[derive(Debug, Clone, Serialize, Deserialize, Default)]
41pub struct NumericRangeWithUnitAndQualifierLowerValue {
42 #[serde(rename = "ValueSymbol", skip_serializing_if = "Option::is_none")]
43 pub value_symbol: Option<String>,
44 #[serde(rename = "Value", skip_serializing_if = "Option::is_none")]
45 pub value: Option<f64>,
46}
47
48#[derive(Debug, Clone, Serialize, Deserialize, Default)]
49pub struct NumericRangeWithUnitAndQualifierUpperValue {
50 #[serde(rename = "ValueSymbol", skip_serializing_if = "Option::is_none")]
51 pub value_symbol: Option<String>,
52 #[serde(rename = "Value", skip_serializing_if = "Option::is_none")]
53 pub value: Option<f64>,
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize, Default)]
57pub struct SubstanceIdentifiers {
58 #[serde(rename = "SubstanceNames", skip_serializing_if = "Option::is_none")]
59 pub substance_names: Option<SubstanceIdentifiersSubstanceNames>,
60 #[serde(rename = "CommonName", skip_serializing_if = "Option::is_none")]
61 pub common_name: Option<SubstanceIdentifiersCommonName>,
62 #[serde(rename = "SubstanceIdentity", skip_serializing_if = "Option::is_none")]
63 pub substance_identity: Option<SubstanceIdentifiersSubstanceIdentity>,
64 #[serde(rename = "CBI", skip_serializing_if = "Option::is_none")]
65 pub cbi: Option<bool>,
66 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
67 pub additional_info: Option<AdditionalInfo>,
68}
69
70#[derive(Debug, Clone, Serialize, Deserialize, Default)]
71pub struct SubstanceIdentifiersCommonName {
72 #[serde(rename = "OtherName", skip_serializing_if = "Option::is_none")]
73 pub other_name: Option<Vec<String>>,
74}
75
76#[derive(Debug, Clone, Serialize, Deserialize, Default)]
77pub struct SubstanceIdentifiersSubstanceIdentity {
78 #[serde(rename = "CASno", skip_serializing_if = "Option::is_none")]
79 pub ca_sno: Option<SubstanceIdentifiersSubstanceIdentityCASno>,
80 #[serde(rename = "OtherNo", skip_serializing_if = "Option::is_none")]
81 pub other_no: Option<Vec<SubstanceIdentifiersSubstanceIdentityOtherNo>>,
82}
83
84#[derive(Debug, Clone, Serialize, Deserialize, Default)]
85pub struct SubstanceIdentifiersSubstanceIdentityCASno {
86 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
88 default, deserialize_with = "crate::schema::serde_flex::flex_vec_string_opt")]
89 pub full_text: Option<Vec<String>>,
90 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
91 pub additional_info: Option<AdditionalInfo>,
92}
93
94#[derive(Debug, Clone, Serialize, Deserialize, Default)]
95pub struct SubstanceIdentifiersSubstanceIdentityOtherNo {
96 #[serde(rename = "IdentityName", skip_serializing_if = "Option::is_none")]
97 pub identity_name: Option<String>,
98 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
99 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
100 pub full_text: Option<String>,
101 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
102 pub additional_info: Option<AdditionalInfo>,
103}
104
105#[derive(Debug, Clone, Serialize, Deserialize, Default)]
106pub struct SubstanceIdentifiersSubstanceNames {
107 #[serde(rename = "IupacName", skip_serializing_if = "Option::is_none")]
108 pub iupac_name: Option<String>,
109 #[serde(rename = "CasInventoryName", skip_serializing_if = "Option::is_none")]
110 pub cas_inventory_name: Option<String>,
111 #[serde(rename = "GenericName", skip_serializing_if = "Option::is_none")]
112 pub generic_name: Option<String>,
113}
114
115#[derive(Debug, Clone, Serialize, Deserialize, Default)]
116pub struct EcotoxicityTestInfo {
117 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
118 pub method: Option<String>,
119 #[serde(rename = "TestGuidline", skip_serializing_if = "Option::is_none")]
120 pub test_guidline: Option<String>,
121 #[serde(rename = "GLP", skip_serializing_if = "Option::is_none")]
122 pub glp: Option<String>,
123 #[serde(rename = "Species", skip_serializing_if = "Option::is_none")]
124 pub species: Option<String>,
125 #[serde(rename = "TestDuration", skip_serializing_if = "Option::is_none")]
126 pub test_duration: Option<String>,
127 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
128 pub result: Option<String>,
129 #[serde(rename = "Dose/Concentration", skip_serializing_if = "Option::is_none")]
130 pub dose_concentration: Option<f64>,
131 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
132 pub unit: Option<String>,
133 #[serde(rename = "TestReference", skip_serializing_if = "Option::is_none")]
134 pub test_reference: Option<String>,
135 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
136 pub additional_info: Option<AdditionalInfo>,
137}
138
139#[derive(Debug, Clone, Serialize, Deserialize, Default)]
140pub struct GazetteNo {
141 #[serde(rename = "CSCL", skip_serializing_if = "Option::is_none")]
142 pub cscl: Option<GazetteNoCSCL>,
143 #[serde(rename = "ISHA", skip_serializing_if = "Option::is_none")]
144 pub isha: Option<GazetteNoISHA>,
145 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
146 pub additional_info: Option<AdditionalInfo>,
147}
148
149#[derive(Debug, Clone, Serialize, Deserialize, Default)]
150pub struct GazetteNoCSCL {
151 #[serde(rename = "CsclGazetteNo", skip_serializing_if = "Option::is_none")]
152 pub cscl_gazette_no: Option<Vec<String>>,
153 #[serde(rename = "Classification", skip_serializing_if = "Option::is_none")]
154 pub classification: Option<Vec<GazetteNoCSCLClassification>>,
155 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
156 pub additional_info: Option<AdditionalInfo>,
157}
158
159#[derive(Debug, Clone, Serialize, Deserialize, Default)]
160pub struct GazetteNoCSCLClassification {
161 #[serde(rename = "ClassificationName", skip_serializing_if = "Option::is_none")]
162 pub classification_name: Option<String>,
163 #[serde(rename = "isApplicable", skip_serializing_if = "Option::is_none")]
164 pub is_applicable: Option<bool>,
165 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
166 pub additional_info: Option<AdditionalInfo>,
167}
168
169#[derive(Debug, Clone, Serialize, Deserialize, Default)]
170pub struct GazetteNoISHA {
171 #[serde(rename = "IshaGazetteNo", skip_serializing_if = "Option::is_none")]
172 pub isha_gazette_no: Option<Vec<String>>,
173 #[serde(rename = "Classification", skip_serializing_if = "Option::is_none")]
174 pub classification: Option<Vec<GazetteNoISHAClassification>>,
175 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
176 pub additional_info: Option<AdditionalInfo>,
177}
178
179#[derive(Debug, Clone, Serialize, Deserialize, Default)]
180pub struct GazetteNoISHAClassification {
181 #[serde(rename = "ClassificationName", skip_serializing_if = "Option::is_none")]
182 pub classification_name: Option<String>,
183 #[serde(rename = "isApplicable", skip_serializing_if = "Option::is_none")]
184 pub is_applicable: Option<bool>,
185 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
186 pub additional_info: Option<AdditionalInfo>,
187}
188
189#[derive(Debug, Clone, Serialize, Deserialize, Default)]
190pub struct ToxicityTestInfo {
191 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
192 pub method: Option<String>,
193 #[serde(rename = "TestGuidline", skip_serializing_if = "Option::is_none")]
194 pub test_guidline: Option<String>,
195 #[serde(rename = "GLP", skip_serializing_if = "Option::is_none")]
196 pub glp: Option<String>,
197 #[serde(rename = "Species", skip_serializing_if = "Option::is_none")]
198 pub species: Option<String>,
199 #[serde(rename = "Gender", skip_serializing_if = "Option::is_none")]
200 pub gender: Option<String>,
201 #[serde(rename = "TestDuration", skip_serializing_if = "Option::is_none")]
202 pub test_duration: Option<String>,
203 #[serde(rename = "ExposureTime", skip_serializing_if = "Option::is_none")]
204 pub exposure_time: Option<String>,
205 #[serde(rename = "ExposureFrequency", skip_serializing_if = "Option::is_none")]
206 pub exposure_frequency: Option<String>,
207 #[serde(rename = "Dose/Concentration", skip_serializing_if = "Option::is_none")]
208 pub dose_concentration: Option<f64>,
209 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
210 pub unit: Option<String>,
211 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
212 pub result: Option<String>,
213 #[serde(rename = "TestReference", skip_serializing_if = "Option::is_none")]
214 pub test_reference: Option<String>,
215 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
216 pub additional_info: Option<AdditionalInfo>,
217}
218
219#[derive(Debug, Clone, Serialize, Deserialize, Default)]
220pub struct AccidentalReleaseMeasures {
221 #[serde(rename = "HumanExposureAndEmergencyMeasuress", skip_serializing_if = "Option::is_none")]
222 pub human_exposure_and_emergency_measuress: Option<AccidentalReleaseMeasuresHumanExposureAndEmergencyMeasuress>,
223 #[serde(rename = "EnvironmentalPrecautions", skip_serializing_if = "Option::is_none")]
224 pub environmental_precautions: Option<AccidentalReleaseMeasuresEnvironmentalPrecautions>,
225 #[serde(rename = "ContainmentAndCleaningUp", skip_serializing_if = "Option::is_none")]
226 pub containment_and_cleaning_up: Option<AccidentalReleaseMeasuresContainmentAndCleaningUp>,
227 #[serde(rename = "SecondaryDisasterPreventionMeasures", skip_serializing_if = "Option::is_none")]
228 pub secondary_disaster_prevention_measures: Option<AccidentalReleaseMeasuresSecondaryDisasterPreventionMeasures>,
229 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
230 pub additional_info: Option<AdditionalInfo>,
231}
232
233#[derive(Debug, Clone, Serialize, Deserialize, Default)]
234pub struct AccidentalReleaseMeasuresContainmentAndCleaningUp {
235 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
236 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
237 pub full_text: Option<String>,
238 #[serde(rename = "Containment", skip_serializing_if = "Option::is_none")]
239 pub containment: Option<String>,
240 #[serde(rename = "CleaningUp", skip_serializing_if = "Option::is_none")]
241 pub cleaning_up: Option<String>,
242 #[serde(rename = "ForSmallQuantity", skip_serializing_if = "Option::is_none")]
243 pub for_small_quantity: Option<String>,
244 #[serde(rename = "ForLargeQuantity", skip_serializing_if = "Option::is_none")]
245 pub for_large_quantity: Option<String>,
246 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
247 pub additional_info: Option<AdditionalInfo>,
248}
249
250#[derive(Debug, Clone, Serialize, Deserialize, Default)]
251pub struct AccidentalReleaseMeasuresEnvironmentalPrecautions {
252 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
253 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
254 pub full_text: Option<String>,
255 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
256 pub additional_info: Option<AdditionalInfo>,
257}
258
259#[derive(Debug, Clone, Serialize, Deserialize, Default)]
260pub struct AccidentalReleaseMeasuresHumanExposureAndEmergencyMeasuress {
261 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
262 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
263 pub full_text: Option<String>,
264 #[serde(rename = "GeneralMeasures", skip_serializing_if = "Option::is_none")]
265 pub general_measures: Option<String>,
266 #[serde(rename = "ForNonEmergencyPersonnel", skip_serializing_if = "Option::is_none")]
267 pub for_non_emergency_personnel: Option<AccidentalReleaseMeasuresHumanExposureAndEmergencyMeasuressForNonEmergencyPersonnel>,
268 #[serde(rename = "ForEmergencyResponders", skip_serializing_if = "Option::is_none")]
269 pub for_emergency_responders: Option<AccidentalReleaseMeasuresHumanExposureAndEmergencyMeasuressForEmergencyResponders>,
270 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
271 pub additional_info: Option<AdditionalInfo>,
272}
273
274#[derive(Debug, Clone, Serialize, Deserialize, Default)]
275pub struct AccidentalReleaseMeasuresHumanExposureAndEmergencyMeasuressForEmergencyResponders {
276 #[serde(rename = "PersonalProtectionEquipment", skip_serializing_if = "Option::is_none")]
277 pub personal_protection_equipment: Option<String>,
278 #[serde(rename = "EmergencyProcedures", skip_serializing_if = "Option::is_none")]
279 pub emergency_procedures: Option<String>,
280}
281
282#[derive(Debug, Clone, Serialize, Deserialize, Default)]
283pub struct AccidentalReleaseMeasuresHumanExposureAndEmergencyMeasuressForNonEmergencyPersonnel {
284 #[serde(rename = "PersonalProtectionEquipment", skip_serializing_if = "Option::is_none")]
285 pub personal_protection_equipment: Option<String>,
286 #[serde(rename = "EmergencyProcedures", skip_serializing_if = "Option::is_none")]
287 pub emergency_procedures: Option<String>,
288}
289
290#[derive(Debug, Clone, Serialize, Deserialize, Default)]
291pub struct AccidentalReleaseMeasuresSecondaryDisasterPreventionMeasures {
292 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
293 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
294 pub full_text: Option<String>,
295 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
296 pub additional_info: Option<AdditionalInfo>,
297}
298
299#[derive(Debug, Clone, Serialize, Deserialize, Default)]
300pub struct Composition {
301 #[serde(rename = "CompositionType", skip_serializing_if = "Option::is_none")]
302 pub composition_type: Option<String>,
303 #[serde(rename = "SubstanceIdentifiers", skip_serializing_if = "Option::is_none")]
304 pub substance_identifiers: Option<SubstanceIdentifiers>,
305 #[serde(rename = "Use", skip_serializing_if = "Option::is_none")]
306 pub r#use: Option<String>,
307 #[serde(rename = "CompositionAndConcentration", skip_serializing_if = "Option::is_none")]
308 pub composition_and_concentration: Option<Vec<CompositionCompositionAndConcentration>>,
309 #[serde(rename = "ImpuritiesAndStabilizingAdditives", skip_serializing_if = "Option::is_none")]
310 pub impurities_and_stabilizing_additives: Option<CompositionImpuritiesAndStabilizingAdditives>,
311 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
312 pub additional_info: Option<AdditionalInfo>,
313}
314
315#[derive(Debug, Clone, Serialize, Deserialize, Default)]
316pub struct CompositionCompositionAndConcentration {
317 #[serde(rename = "SubstanceIdentifiers", skip_serializing_if = "Option::is_none")]
318 pub substance_identifiers: Option<SubstanceIdentifiers>,
319 #[serde(rename = "MolecularFormula", skip_serializing_if = "Option::is_none")]
320 pub molecular_formula: Option<String>,
321 #[serde(rename = "StructuralFormula", skip_serializing_if = "Option::is_none")]
322 pub structural_formula: Option<String>,
323 #[serde(rename = "StructuralFormulaPathAndFileName", skip_serializing_if = "Option::is_none")]
324 pub structural_formula_path_and_file_name: Option<String>,
325 #[serde(rename = "SMILES", skip_serializing_if = "Option::is_none")]
326 pub smiles: Option<String>,
327 #[serde(rename = "InChI", skip_serializing_if = "Option::is_none")]
328 pub in_ch_i: Option<String>,
329 #[serde(rename = "InChIKey", skip_serializing_if = "Option::is_none")]
330 pub in_ch_i_key: Option<String>,
331 #[serde(rename = "MolecularWeight", skip_serializing_if = "Option::is_none")]
332 pub molecular_weight: Option<f64>,
333 #[serde(rename = "Concentration", skip_serializing_if = "Option::is_none")]
334 pub concentration: Option<CompositionCompositionAndConcentrationConcentration>,
335 #[serde(rename = "gazetteNo", skip_serializing_if = "Option::is_none")]
336 pub gazette_no: Option<GazetteNo>,
337 #[serde(rename = "Use", skip_serializing_if = "Option::is_none")]
338 pub r#use: Option<String>,
339 #[serde(rename = "GHSinfo", skip_serializing_if = "Option::is_none")]
340 pub gh_sinfo: Option<String>,
341 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
342 pub additional_info: Option<AdditionalInfo>,
343}
344
345#[derive(Debug, Clone, Serialize, Deserialize, Default)]
346pub struct CompositionCompositionAndConcentrationConcentration {
347 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
348 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
349}
350
351#[derive(Debug, Clone, Serialize, Deserialize, Default)]
352pub struct CompositionImpuritiesAndStabilizingAdditives {
353 #[serde(rename = "isPresent", skip_serializing_if = "Option::is_none")]
354 pub is_present: Option<bool>,
355 #[serde(rename = "SubstancesAndConcentration", skip_serializing_if = "Option::is_none")]
356 pub substances_and_concentration: Option<Vec<CompositionImpuritiesAndStabilizingAdditivesSubstancesAndConcentration>>,
357 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
358 pub additional_info: Option<AdditionalInfo>,
359}
360
361#[derive(Debug, Clone, Serialize, Deserialize, Default)]
362pub struct CompositionImpuritiesAndStabilizingAdditivesSubstancesAndConcentration {
363 #[serde(rename = "SubstanceIdentifiers", skip_serializing_if = "Option::is_none")]
364 pub substance_identifiers: Option<SubstanceIdentifiers>,
365 #[serde(rename = "MolecularFormula", skip_serializing_if = "Option::is_none")]
366 pub molecular_formula: Option<String>,
367 #[serde(rename = "StructuralFormula", skip_serializing_if = "Option::is_none")]
368 pub structural_formula: Option<String>,
369 #[serde(rename = "StructuralFormulaPathAndFileName", skip_serializing_if = "Option::is_none")]
370 pub structural_formula_path_and_file_name: Option<String>,
371 #[serde(rename = "SMILES", skip_serializing_if = "Option::is_none")]
372 pub smiles: Option<String>,
373 #[serde(rename = "InChI", skip_serializing_if = "Option::is_none")]
374 pub in_ch_i: Option<String>,
375 #[serde(rename = "InChIKey", skip_serializing_if = "Option::is_none")]
376 pub in_ch_i_key: Option<String>,
377 #[serde(rename = "MolecularWeight", skip_serializing_if = "Option::is_none")]
378 pub molecular_weight: Option<f64>,
379 #[serde(rename = "Concentration", skip_serializing_if = "Option::is_none")]
380 pub concentration: Option<CompositionImpuritiesAndStabilizingAdditivesSubstancesAndConcentrationConcentration>,
381 #[serde(rename = "gazetteNo", skip_serializing_if = "Option::is_none")]
382 pub gazette_no: Option<GazetteNo>,
383 #[serde(rename = "Use", skip_serializing_if = "Option::is_none")]
384 pub r#use: Option<String>,
385 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
386 pub additional_info: Option<AdditionalInfo>,
387}
388
389#[derive(Debug, Clone, Serialize, Deserialize, Default)]
390pub struct CompositionImpuritiesAndStabilizingAdditivesSubstancesAndConcentrationConcentration {
391 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
392 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
393}
394
395#[derive(Debug, Clone, Serialize, Deserialize, Default)]
396pub struct Datasheet {
397 #[serde(rename = "IssueDate", skip_serializing_if = "Option::is_none")]
398 pub issue_date: Option<String>,
399 #[serde(rename = "RevisionDate", skip_serializing_if = "Option::is_none")]
400 pub revision_date: Option<Vec<String>>,
401 #[serde(rename = "VersionNo", skip_serializing_if = "Option::is_none")]
402 pub version_no: Option<Vec<String>>,
403 #[serde(rename = "JISVersionNo", skip_serializing_if = "Option::is_none")]
404 pub jis_version_no: Option<Vec<String>>,
405 #[serde(rename = "SDS-SchemaVersionNo", skip_serializing_if = "Option::is_none")]
406 pub sds_schema_version_no: Option<String>,
407 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
408 pub additional_info: Option<AdditionalInfo>,
409}
410
411#[derive(Debug, Clone, Serialize, Deserialize, Default)]
412pub struct DisposalConsiderations {
413 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
414 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
415 pub full_text: Option<String>,
416 #[serde(rename = "ProductWaste", skip_serializing_if = "Option::is_none")]
417 pub product_waste: Option<Vec<String>>,
418 #[serde(rename = "PackagingWaste", skip_serializing_if = "Option::is_none")]
419 pub packaging_waste: Option<Vec<String>>,
420 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
421 pub additional_info: Option<AdditionalInfo>,
422}
423
424#[derive(Debug, Clone, Serialize, Deserialize, Default)]
425pub struct EcologicalInformation {
426 #[serde(rename = "CompositionType", skip_serializing_if = "Option::is_none")]
427 pub composition_type: Option<String>,
428 #[serde(rename = "SubstanceIdentifiers", skip_serializing_if = "Option::is_none")]
429 pub substance_identifiers: Option<SubstanceIdentifiers>,
430 #[serde(rename = "EcotoxicologicalInformation", skip_serializing_if = "Option::is_none")]
431 pub ecotoxicological_information: Option<EcologicalInformationEcotoxicologicalInformation>,
432 #[serde(rename = "PersistenceDegradability", skip_serializing_if = "Option::is_none")]
433 pub persistence_degradability: Option<EcologicalInformationPersistenceDegradability>,
434 #[serde(rename = "Bioaccumulation", skip_serializing_if = "Option::is_none")]
435 pub bioaccumulation: Option<EcologicalInformationBioaccumulation>,
436 #[serde(rename = "Mobility", skip_serializing_if = "Option::is_none")]
437 pub mobility: Option<EcologicalInformationMobility>,
438 #[serde(rename = "HazardousOzoneLayer", skip_serializing_if = "Option::is_none")]
439 pub hazardous_ozone_layer: Option<EcologicalInformationHazardousOzoneLayer>,
440 #[serde(rename = "AdditionalEcotoxInformation", skip_serializing_if = "Option::is_none")]
441 pub additional_ecotox_information: Option<String>,
442 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
443 pub additional_info: Option<AdditionalInfo>,
444}
445
446#[derive(Debug, Clone, Serialize, Deserialize, Default)]
447pub struct EcologicalInformationBioaccumulation {
448 #[serde(rename = "BioconcentrationFactor", skip_serializing_if = "Option::is_none")]
449 pub bioconcentration_factor: Option<EcologicalInformationBioaccumulationBioconcentrationFactor>,
450 #[serde(rename = "LogKoW", skip_serializing_if = "Option::is_none")]
451 pub log_ko_w: Option<f64>,
452 #[serde(rename = "Bioaccumulation", skip_serializing_if = "Option::is_none")]
453 pub bioaccumulation: Option<String>,
454 #[serde(rename = "TestReference", skip_serializing_if = "Option::is_none")]
455 pub test_reference: Option<String>,
456 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
457 pub additional_info: Option<AdditionalInfo>,
458}
459
460#[derive(Debug, Clone, Serialize, Deserialize, Default)]
461pub struct EcologicalInformationBioaccumulationBioconcentrationFactor {
462 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
463 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
464 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
465 pub additional_info: Option<AdditionalInfo>,
466}
467
468#[derive(Debug, Clone, Serialize, Deserialize, Default)]
469pub struct EcologicalInformationEcotoxicologicalInformation {
470 #[serde(rename = "AquaticAcuteToxicity", skip_serializing_if = "Option::is_none")]
471 pub aquatic_acute_toxicity: Option<EcologicalInformationEcotoxicologicalInformationAquaticAcuteToxicity>,
472 #[serde(rename = "AquaticChronicToxicity", skip_serializing_if = "Option::is_none")]
473 pub aquatic_chronic_toxicity: Option<EcologicalInformationEcotoxicologicalInformationAquaticChronicToxicity>,
474}
475
476#[derive(Debug, Clone, Serialize, Deserialize, Default)]
477pub struct EcologicalInformationEcotoxicologicalInformationAquaticAcuteToxicity {
478 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
479 pub category: Option<String>,
480 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
481 pub rationale: Option<String>,
482 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
483 pub result: Option<Vec<EcologicalInformationEcotoxicologicalInformationAquaticAcuteToxicityResult>>,
484 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
485 pub additional_info: Option<AdditionalInfo>,
486}
487
488#[derive(Debug, Clone, Serialize, Deserialize, Default)]
489pub struct EcologicalInformationEcotoxicologicalInformationAquaticAcuteToxicityResult {
490 #[serde(rename = "ecotoxicityTestInfo", skip_serializing_if = "Option::is_none")]
491 pub ecotoxicity_test_info: Option<EcotoxicityTestInfo>,
492 #[serde(rename = "ValueType", skip_serializing_if = "Option::is_none")]
493 pub value_type: Option<String>,
494 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
495 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
496 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
497 pub additional_info: Option<AdditionalInfo>,
498}
499
500#[derive(Debug, Clone, Serialize, Deserialize, Default)]
501pub struct EcologicalInformationEcotoxicologicalInformationAquaticChronicToxicity {
502 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
503 pub category: Option<String>,
504 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
505 pub rationale: Option<String>,
506 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
507 pub result: Option<Vec<EcologicalInformationEcotoxicologicalInformationAquaticChronicToxicityResult>>,
508 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
509 pub additional_info: Option<AdditionalInfo>,
510}
511
512#[derive(Debug, Clone, Serialize, Deserialize, Default)]
513pub struct EcologicalInformationEcotoxicologicalInformationAquaticChronicToxicityResult {
514 #[serde(rename = "ecotoxicityTestInfo", skip_serializing_if = "Option::is_none")]
515 pub ecotoxicity_test_info: Option<EcotoxicityTestInfo>,
516 #[serde(rename = "ValueType", skip_serializing_if = "Option::is_none")]
517 pub value_type: Option<String>,
518 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
519 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
520 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
521 pub additional_info: Option<AdditionalInfo>,
522}
523
524#[derive(Debug, Clone, Serialize, Deserialize, Default)]
525pub struct EcologicalInformationHazardousOzoneLayer {
526 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
527 pub category: Option<String>,
528 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
529 pub rationale: Option<String>,
530 #[serde(rename = "AnnexMontrealProtocol", skip_serializing_if = "Option::is_none")]
531 pub annex_montreal_protocol: Option<bool>,
532 #[serde(rename = "OzoneDepletionPotential", skip_serializing_if = "Option::is_none")]
533 pub ozone_depletion_potential: Option<f64>,
534 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
535 pub additional_info: Option<AdditionalInfo>,
536}
537
538#[derive(Debug, Clone, Serialize, Deserialize, Default)]
539pub struct EcologicalInformationMobility {
540 #[serde(rename = "AdsorptionCoefficient", skip_serializing_if = "Option::is_none")]
541 pub adsorption_coefficient: Option<EcologicalInformationMobilityAdsorptionCoefficient>,
542 #[serde(rename = "Mobility", skip_serializing_if = "Option::is_none")]
543 pub mobility: Option<String>,
544 #[serde(rename = "TestReference", skip_serializing_if = "Option::is_none")]
545 pub test_reference: Option<String>,
546 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
547 pub additional_info: Option<AdditionalInfo>,
548}
549
550#[derive(Debug, Clone, Serialize, Deserialize, Default)]
551pub struct EcologicalInformationMobilityAdsorptionCoefficient {
552 #[serde(rename = "KoC", skip_serializing_if = "Option::is_none")]
553 pub ko_c: Option<NumericRangeWithUnitAndQualifier>,
554 #[serde(rename = "Kd", skip_serializing_if = "Option::is_none")]
555 pub kd: Option<NumericRangeWithUnitAndQualifier>,
556}
557
558#[derive(Debug, Clone, Serialize, Deserialize, Default)]
559pub struct EcologicalInformationPersistenceDegradability {
560 #[serde(rename = "BiologicalDegradability", skip_serializing_if = "Option::is_none")]
561 pub biological_degradability: Option<String>,
562 #[serde(rename = "AbioticDegradation", skip_serializing_if = "Option::is_none")]
563 pub abiotic_degradation: Option<String>,
564 #[serde(rename = "RapidDegradability", skip_serializing_if = "Option::is_none")]
565 pub rapid_degradability: Option<bool>,
566 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
567 pub additional_info: Option<AdditionalInfo>,
568}
569
570#[derive(Debug, Clone, Serialize, Deserialize, Default)]
571pub struct ExposureControlPersonalProtection {
572 #[serde(rename = "OccupationalExposureLimits", skip_serializing_if = "Option::is_none")]
573 pub occupational_exposure_limits: Option<Vec<ExposureControlPersonalProtectionOccupationalExposureLimits>>,
574 #[serde(rename = "AppropriateEngineeringControls", skip_serializing_if = "Option::is_none")]
575 pub appropriate_engineering_controls: Option<Vec<String>>,
576 #[serde(rename = "PersonalProtectionEquipment", skip_serializing_if = "Option::is_none")]
577 pub personal_protection_equipment: Option<ExposureControlPersonalProtectionPersonalProtectionEquipment>,
578 #[serde(rename = "SpecialInstructions", skip_serializing_if = "Option::is_none")]
579 pub special_instructions: Option<Vec<String>>,
580 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
581 pub additional_info: Option<AdditionalInfo>,
582}
583
584#[derive(Debug, Clone, Serialize, Deserialize, Default)]
585pub struct ExposureControlPersonalProtectionOccupationalExposureLimits {
586 #[serde(rename = "SubstanceIdentifiers", skip_serializing_if = "Option::is_none")]
587 pub substance_identifiers: Option<SubstanceIdentifiers>,
588 #[serde(rename = "DecompositionProduct", skip_serializing_if = "Option::is_none")]
589 pub decomposition_product: Option<bool>,
590 #[serde(rename = "ControlConcentration", skip_serializing_if = "Option::is_none")]
591 pub control_concentration: Option<ExposureControlPersonalProtectionOccupationalExposureLimitsControlConcentration>,
592 #[serde(rename = "OccupationalExposureLimit", skip_serializing_if = "Option::is_none")]
593 pub occupational_exposure_limit: Option<Vec<ExposureControlPersonalProtectionOccupationalExposureLimitsOccupationalExposureLimit>>,
594 #[serde(rename = "BiologicalLimitValue", skip_serializing_if = "Option::is_none")]
595 pub biological_limit_value: Option<Vec<ExposureControlPersonalProtectionOccupationalExposureLimitsBiologicalLimitValue>>,
596 #[serde(rename = "EnvironmentalExposurePrevention", skip_serializing_if = "Option::is_none")]
597 pub environmental_exposure_prevention: Option<ExposureControlPersonalProtectionOccupationalExposureLimitsEnvironmentalExposurePrevention>,
598 #[serde(rename = "ExposureGuidelines", skip_serializing_if = "Option::is_none")]
599 pub exposure_guidelines: Option<String>,
600 #[serde(rename = "GuidelineValuesForIndoorAirConcentration", skip_serializing_if = "Option::is_none")]
601 pub guideline_values_for_indoor_air_concentration: Option<String>,
602 #[serde(rename = "RecommendedMonitoringProcedure", skip_serializing_if = "Option::is_none")]
603 pub recommended_monitoring_procedure: Option<String>,
604 #[serde(rename = "AppropriateTechnicalManagement", skip_serializing_if = "Option::is_none")]
605 pub appropriate_technical_management: Option<String>,
606 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
607 pub additional_info: Option<AdditionalInfo>,
608}
609
610#[derive(Debug, Clone, Serialize, Deserialize, Default)]
611pub struct ExposureControlPersonalProtectionOccupationalExposureLimitsBiologicalLimitValue {
612 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
613 pub item_name: Option<String>,
614 #[serde(rename = "SamplingTime", skip_serializing_if = "Option::is_none")]
615 pub sampling_time: Option<String>,
616 #[serde(rename = "Sample", skip_serializing_if = "Option::is_none")]
617 pub sample: Option<String>,
618 #[serde(rename = "substance", skip_serializing_if = "Option::is_none")]
619 pub substance: Option<String>,
620 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
621 pub numeric_range_with_unit_and_qualifier: Option<Vec<NumericRangeWithUnitAndQualifier>>,
622 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
623 pub additional_info: Option<AdditionalInfo>,
624}
625
626#[derive(Debug, Clone, Serialize, Deserialize, Default)]
627pub struct ExposureControlPersonalProtectionOccupationalExposureLimitsControlConcentration {
628 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
629 pub numeric_range_with_unit_and_qualifier: Option<Vec<NumericRangeWithUnitAndQualifier>>,
630}
631
632#[derive(Debug, Clone, Serialize, Deserialize, Default)]
633pub struct ExposureControlPersonalProtectionOccupationalExposureLimitsEnvironmentalExposurePrevention {
634 #[serde(rename = "PNEC", skip_serializing_if = "Option::is_none")]
635 pub pnec: Option<Vec<NumericRangeWithUnitAndQualifier>>,
636 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
637 pub additional_info: Option<AdditionalInfo>,
638}
639
640#[derive(Debug, Clone, Serialize, Deserialize, Default)]
641pub struct ExposureControlPersonalProtectionOccupationalExposureLimitsOccupationalExposureLimit {
642 #[serde(rename = "LimitValueTypeWithCountryOrOrganisation", skip_serializing_if = "Option::is_none")]
643 pub limit_value_type_with_country_or_organisation: Option<String>,
644 #[serde(rename = "LimitValue", skip_serializing_if = "Option::is_none")]
645 pub limit_value: Option<ExposureControlPersonalProtectionOccupationalExposureLimitsOccupationalExposureLimitLimitValue>,
646 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
647 pub additional_info: Option<AdditionalInfo>,
648}
649
650#[derive(Debug, Clone, Serialize, Deserialize, Default)]
651pub struct ExposureControlPersonalProtectionOccupationalExposureLimitsOccupationalExposureLimitLimitValue {
652 #[serde(rename = "Limit8H", skip_serializing_if = "Option::is_none")]
653 pub limit8_h: Option<ExposureControlPersonalProtectionOccupationalExposureLimitsOccupationalExposureLimitLimitValueLimit8H>,
654 #[serde(rename = "LimitShortTerm", skip_serializing_if = "Option::is_none")]
655 pub limit_short_term: Option<ExposureControlPersonalProtectionOccupationalExposureLimitsOccupationalExposureLimitLimitValueLimitShortTerm>,
656 #[serde(rename = "PeakLimitation", skip_serializing_if = "Option::is_none")]
657 pub peak_limitation: Option<ExposureControlPersonalProtectionOccupationalExposureLimitsOccupationalExposureLimitLimitValuePeakLimitation>,
658 #[serde(rename = "OtherLimitation", skip_serializing_if = "Option::is_none")]
659 pub other_limitation: Option<Vec<ExposureControlPersonalProtectionOccupationalExposureLimitsOccupationalExposureLimitLimitValueOtherLimitation>>,
660}
661
662#[derive(Debug, Clone, Serialize, Deserialize, Default)]
663pub struct ExposureControlPersonalProtectionOccupationalExposureLimitsOccupationalExposureLimitLimitValueLimit8H {
664 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
665 pub item_name: Option<String>,
666 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
667 pub numeric_range_with_unit_and_qualifier: Option<Vec<NumericRangeWithUnitAndQualifier>>,
668 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
669 pub additional_info: Option<AdditionalInfo>,
670}
671
672#[derive(Debug, Clone, Serialize, Deserialize, Default)]
673pub struct ExposureControlPersonalProtectionOccupationalExposureLimitsOccupationalExposureLimitLimitValueLimitShortTerm {
674 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
675 pub item_name: Option<String>,
676 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
677 pub numeric_range_with_unit_and_qualifier: Option<Vec<NumericRangeWithUnitAndQualifier>>,
678 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
679 pub additional_info: Option<AdditionalInfo>,
680}
681
682#[derive(Debug, Clone, Serialize, Deserialize, Default)]
683pub struct ExposureControlPersonalProtectionOccupationalExposureLimitsOccupationalExposureLimitLimitValueOtherLimitation {
684 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
685 pub item_name: Option<String>,
686 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
687 pub numeric_range_with_unit_and_qualifier: Option<Vec<NumericRangeWithUnitAndQualifier>>,
688 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
689 pub additional_info: Option<AdditionalInfo>,
690}
691
692#[derive(Debug, Clone, Serialize, Deserialize, Default)]
693pub struct ExposureControlPersonalProtectionOccupationalExposureLimitsOccupationalExposureLimitLimitValuePeakLimitation {
694 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
695 pub item_name: Option<String>,
696 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
697 pub numeric_range_with_unit_and_qualifier: Option<Vec<NumericRangeWithUnitAndQualifier>>,
698 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
699 pub additional_info: Option<AdditionalInfo>,
700}
701
702#[derive(Debug, Clone, Serialize, Deserialize, Default)]
703pub struct ExposureControlPersonalProtectionPersonalProtectionEquipment {
704 #[serde(rename = "RespiratoryProtection", skip_serializing_if = "Option::is_none")]
705 pub respiratory_protection: Option<Vec<ExposureControlPersonalProtectionPersonalProtectionEquipmentRespiratoryProtection>>,
706 #[serde(rename = "HandProtection", skip_serializing_if = "Option::is_none")]
707 pub hand_protection: Option<Vec<ExposureControlPersonalProtectionPersonalProtectionEquipmentHandProtection>>,
708 #[serde(rename = "EyeProtection", skip_serializing_if = "Option::is_none")]
709 pub eye_protection: Option<Vec<ExposureControlPersonalProtectionPersonalProtectionEquipmentEyeProtection>>,
710 #[serde(rename = "SkinProtection", skip_serializing_if = "Option::is_none")]
711 pub skin_protection: Option<Vec<ExposureControlPersonalProtectionPersonalProtectionEquipmentSkinProtection>>,
712 #[serde(rename = "SpecialTreatmentNeeded", skip_serializing_if = "Option::is_none")]
713 pub special_treatment_needed: Option<ExposureControlPersonalProtectionPersonalProtectionEquipmentSpecialTreatmentNeeded>,
714 #[serde(rename = "GeneralSafetyAndHealthMeasures", skip_serializing_if = "Option::is_none")]
715 pub general_safety_and_health_measures: Option<String>,
716 #[serde(rename = "SafetySigns", skip_serializing_if = "Option::is_none")]
717 pub safety_signs: Option<Vec<String>>,
718}
719
720#[derive(Debug, Clone, Serialize, Deserialize, Default)]
721pub struct ExposureControlPersonalProtectionPersonalProtectionEquipmentEyeProtection {
722 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
723 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
724 pub full_text: Option<String>,
725 #[serde(rename = "SuitableEyeProtection", skip_serializing_if = "Option::is_none")]
726 pub suitable_eye_protection: Option<ExposureControlPersonalProtectionPersonalProtectionEquipmentEyeProtectionSuitableEyeProtection>,
727 #[serde(rename = "UnSuitableEyeProtection", skip_serializing_if = "Option::is_none")]
728 pub un_suitable_eye_protection: Option<String>,
729 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
730 pub additional_info: Option<AdditionalInfo>,
731}
732
733#[derive(Debug, Clone, Serialize, Deserialize, Default)]
734pub struct ExposureControlPersonalProtectionPersonalProtectionEquipmentEyeProtectionSuitableEyeProtection {
735 #[serde(rename = "Type", skip_serializing_if = "Option::is_none")]
736 pub r#type: Option<String>,
737 #[serde(rename = "Standard", skip_serializing_if = "Option::is_none")]
738 pub standard: Option<String>,
739 #[serde(rename = "Manufacturer", skip_serializing_if = "Option::is_none")]
740 pub manufacturer: Option<String>,
741 #[serde(rename = "ProductInfomation", skip_serializing_if = "Option::is_none")]
742 pub product_infomation: Option<String>,
743 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
744 pub additional_info: Option<AdditionalInfo>,
745}
746
747#[derive(Debug, Clone, Serialize, Deserialize, Default)]
748pub struct ExposureControlPersonalProtectionPersonalProtectionEquipmentHandProtection {
749 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
750 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
751 pub full_text: Option<String>,
752 #[serde(rename = "Type", skip_serializing_if = "Option::is_none")]
753 pub r#type: Option<String>,
754 #[serde(rename = "RecommendedProtectiveGloveArticles", skip_serializing_if = "Option::is_none")]
755 pub recommended_protective_glove_articles: Option<Vec<ExposureControlPersonalProtectionPersonalProtectionEquipmentHandProtectionRecommendedProtectiveGloveArticles>>,
756 #[serde(rename = "UnsuitableMaterials", skip_serializing_if = "Option::is_none")]
757 pub unsuitable_materials: Option<Vec<String>>,
758 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
759 pub additional_info: Option<AdditionalInfo>,
760}
761
762#[derive(Debug, Clone, Serialize, Deserialize, Default)]
763pub struct ExposureControlPersonalProtectionPersonalProtectionEquipmentHandProtectionRecommendedProtectiveGloveArticles {
764 #[serde(rename = "Material", skip_serializing_if = "Option::is_none")]
765 pub material: Option<String>,
766 #[serde(rename = "ThicknessOfGloveMaterial", skip_serializing_if = "Option::is_none")]
767 pub thickness_of_glove_material: Option<NumericRangeWithUnitAndQualifier>,
768 #[serde(rename = "GloveBreakthroughTime", skip_serializing_if = "Option::is_none")]
769 pub glove_breakthrough_time: Option<ExposureControlPersonalProtectionPersonalProtectionEquipmentHandProtectionRecommendedProtectiveGloveArticlesGloveBreakthroughTime>,
770 #[serde(rename = "MaxWearDurationPermanentContact", skip_serializing_if = "Option::is_none")]
771 pub max_wear_duration_permanent_contact: Option<NumericRangeWithUnitAndQualifier>,
772 #[serde(rename = "Standard", skip_serializing_if = "Option::is_none")]
773 pub standard: Option<String>,
774 #[serde(rename = "Manufacturer", skip_serializing_if = "Option::is_none")]
775 pub manufacturer: Option<String>,
776 #[serde(rename = "ProductInfomation", skip_serializing_if = "Option::is_none")]
777 pub product_infomation: Option<String>,
778}
779
780#[derive(Debug, Clone, Serialize, Deserialize, Default)]
781pub struct ExposureControlPersonalProtectionPersonalProtectionEquipmentHandProtectionRecommendedProtectiveGloveArticlesGloveBreakthroughTime {
782 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
783 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
784 #[serde(rename = "PermeationChart", skip_serializing_if = "Option::is_none")]
785 pub permeation_chart: Option<i64>,
786}
787
788#[derive(Debug, Clone, Serialize, Deserialize, Default)]
789pub struct ExposureControlPersonalProtectionPersonalProtectionEquipmentRespiratoryProtection {
790 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
791 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
792 pub full_text: Option<String>,
793 #[serde(rename = "TasksNeedingRespiratoryProtection", skip_serializing_if = "Option::is_none")]
794 pub tasks_needing_respiratory_protection: Option<String>,
795 #[serde(rename = "SuitableRespiratoryProtectionEquipment", skip_serializing_if = "Option::is_none")]
796 pub suitable_respiratory_protection_equipment: Option<Vec<ExposureControlPersonalProtectionPersonalProtectionEquipmentRespiratoryProtectionSuitableRespiratoryProtectionEquipment>>,
797 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
798 pub additional_info: Option<AdditionalInfo>,
799}
800
801#[derive(Debug, Clone, Serialize, Deserialize, Default)]
802pub struct ExposureControlPersonalProtectionPersonalProtectionEquipmentRespiratoryProtectionSuitableRespiratoryProtectionEquipment {
803 #[serde(rename = "MaskType", skip_serializing_if = "Option::is_none")]
804 pub mask_type: Option<String>,
805 #[serde(rename = "FilterApparatusType", skip_serializing_if = "Option::is_none")]
806 pub filter_apparatus_type: Option<String>,
807 #[serde(rename = "Standard", skip_serializing_if = "Option::is_none")]
808 pub standard: Option<String>,
809 #[serde(rename = "Description", skip_serializing_if = "Option::is_none")]
810 pub description: Option<String>,
811 #[serde(rename = "Manufacturer", skip_serializing_if = "Option::is_none")]
812 pub manufacturer: Option<String>,
813 #[serde(rename = "ProductInfomation", skip_serializing_if = "Option::is_none")]
814 pub product_infomation: Option<String>,
815 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
816 pub additional_info: Option<AdditionalInfo>,
817}
818
819#[derive(Debug, Clone, Serialize, Deserialize, Default)]
820pub struct ExposureControlPersonalProtectionPersonalProtectionEquipmentSkinProtection {
821 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
822 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
823 pub full_text: Option<String>,
824 #[serde(rename = "SuitableProtectiveClothing", skip_serializing_if = "Option::is_none")]
825 pub suitable_protective_clothing: Option<ExposureControlPersonalProtectionPersonalProtectionEquipmentSkinProtectionSuitableProtectiveClothing>,
826 #[serde(rename = "UnsuitableProtectiveClothing", skip_serializing_if = "Option::is_none")]
827 pub unsuitable_protective_clothing: Option<String>,
828 #[serde(rename = "AdditionalSkinProtectionMeasures", skip_serializing_if = "Option::is_none")]
829 pub additional_skin_protection_measures: Option<String>,
830 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
831 pub additional_info: Option<AdditionalInfo>,
832}
833
834#[derive(Debug, Clone, Serialize, Deserialize, Default)]
835pub struct ExposureControlPersonalProtectionPersonalProtectionEquipmentSkinProtectionSuitableProtectiveClothing {
836 #[serde(rename = "RecommendedProtectiveClothingArticles", skip_serializing_if = "Option::is_none")]
837 pub recommended_protective_clothing_articles: Option<Vec<ExposureControlPersonalProtectionPersonalProtectionEquipmentSkinProtectionSuitableProtectiveClothingRecommendedProtectiveClothingArticles>>,
838}
839
840#[derive(Debug, Clone, Serialize, Deserialize, Default)]
841pub struct ExposureControlPersonalProtectionPersonalProtectionEquipmentSkinProtectionSuitableProtectiveClothingRecommendedProtectiveClothingArticles {
842 #[serde(rename = "Material", skip_serializing_if = "Option::is_none")]
843 pub material: Option<String>,
844 #[serde(rename = "ThicknessOfGloveMaterial", skip_serializing_if = "Option::is_none")]
845 pub thickness_of_glove_material: Option<NumericRangeWithUnitAndQualifier>,
846 #[serde(rename = "GloveBreakthroughTime", skip_serializing_if = "Option::is_none")]
847 pub glove_breakthrough_time: Option<ExposureControlPersonalProtectionPersonalProtectionEquipmentSkinProtectionSuitableProtectiveClothingRecommendedProtectiveClothingArticlesGloveBreakthroughTime>,
848 #[serde(rename = "MaxWearDurationPermanentContact", skip_serializing_if = "Option::is_none")]
849 pub max_wear_duration_permanent_contact: Option<NumericRangeWithUnitAndQualifier>,
850 #[serde(rename = "Standard", skip_serializing_if = "Option::is_none")]
851 pub standard: Option<String>,
852 #[serde(rename = "Manufacturer", skip_serializing_if = "Option::is_none")]
853 pub manufacturer: Option<String>,
854 #[serde(rename = "ProductInfomation", skip_serializing_if = "Option::is_none")]
855 pub product_infomation: Option<String>,
856}
857
858#[derive(Debug, Clone, Serialize, Deserialize, Default)]
859pub struct ExposureControlPersonalProtectionPersonalProtectionEquipmentSkinProtectionSuitableProtectiveClothingRecommendedProtectiveClothingArticlesGloveBreakthroughTime {
860 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
861 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
862 #[serde(rename = "PermeationChart", skip_serializing_if = "Option::is_none")]
863 pub permeation_chart: Option<i64>,
864}
865
866#[derive(Debug, Clone, Serialize, Deserialize, Default)]
867pub struct ExposureControlPersonalProtectionPersonalProtectionEquipmentSpecialTreatmentNeeded {
868 #[serde(rename = "ThermalHazardsProtection", skip_serializing_if = "Option::is_none")]
869 pub thermal_hazards_protection: Option<String>,
870 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
871 pub additional_info: Option<AdditionalInfo>,
872}
873
874#[derive(Debug, Clone, Serialize, Deserialize, Default)]
875pub struct FireFightingMeasures {
876 #[serde(rename = "MediaToBeUsed", skip_serializing_if = "Option::is_none")]
877 pub media_to_be_used: Option<FireFightingMeasuresMediaToBeUsed>,
878 #[serde(rename = "MediaNotBeUsed", skip_serializing_if = "Option::is_none")]
879 pub media_not_be_used: Option<FireFightingMeasuresMediaNotBeUsed>,
880 #[serde(rename = "FireAndExplosionHazards", skip_serializing_if = "Option::is_none")]
881 pub fire_and_explosion_hazards: Option<FireFightingMeasuresFireAndExplosionHazards>,
882 #[serde(rename = "FireFightingProcedures", skip_serializing_if = "Option::is_none")]
883 pub fire_fighting_procedures: Option<FireFightingMeasuresFireFightingProcedures>,
884 #[serde(rename = "SpecialProtectiveEquipmentForFirefighters", skip_serializing_if = "Option::is_none")]
885 pub special_protective_equipment_for_firefighters: Option<FireFightingMeasuresSpecialProtectiveEquipmentForFirefighters>,
886 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
887 pub additional_info: Option<AdditionalInfo>,
888}
889
890#[derive(Debug, Clone, Serialize, Deserialize, Default)]
891pub struct FireFightingMeasuresFireAndExplosionHazards {
892 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
893 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
894 pub full_text: Option<String>,
895 #[serde(rename = "HazardCombustionProd", skip_serializing_if = "Option::is_none")]
896 pub hazard_combustion_prod: Option<String>,
897 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
898 pub additional_info: Option<AdditionalInfo>,
899}
900
901#[derive(Debug, Clone, Serialize, Deserialize, Default)]
902pub struct FireFightingMeasuresFireFightingProcedures {
903 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
904 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
905 pub full_text: Option<String>,
906 #[serde(rename = "InitialFireFightingMethod", skip_serializing_if = "Option::is_none")]
907 pub initial_fire_fighting_method: Option<String>,
908 #[serde(rename = "LargeScaleFireFightingMethod", skip_serializing_if = "Option::is_none")]
909 pub large_scale_fire_fighting_method: Option<String>,
910 #[serde(rename = "SurroundingFireProcedures", skip_serializing_if = "Option::is_none")]
911 pub surrounding_fire_procedures: Option<String>,
912 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
913 pub additional_info: Option<AdditionalInfo>,
914}
915
916#[derive(Debug, Clone, Serialize, Deserialize, Default)]
917pub struct FireFightingMeasuresMediaNotBeUsed {
918 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
919 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
920 pub full_text: Option<String>,
921 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
922 pub additional_info: Option<AdditionalInfo>,
923}
924
925#[derive(Debug, Clone, Serialize, Deserialize, Default)]
926pub struct FireFightingMeasuresMediaToBeUsed {
927 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
928 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
929 pub full_text: Option<String>,
930 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
931 pub additional_info: Option<AdditionalInfo>,
932}
933
934#[derive(Debug, Clone, Serialize, Deserialize, Default)]
935pub struct FireFightingMeasuresSpecialProtectiveEquipmentForFirefighters {
936 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
937 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
938 pub full_text: Option<String>,
939 #[serde(rename = "SpecialProtectiveEquipmentAndPreventiveMeasuresForFirefighters", skip_serializing_if = "Option::is_none")]
940 pub special_protective_equipment_and_preventive_measures_for_firefighters: Option<String>,
941 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
942 pub additional_info: Option<AdditionalInfo>,
943}
944
945#[derive(Debug, Clone, Serialize, Deserialize, Default)]
946pub struct FirstAidMeasures {
947 #[serde(rename = "ExposureRoute", skip_serializing_if = "Option::is_none")]
948 pub exposure_route: Option<FirstAidMeasuresExposureRoute>,
949 #[serde(rename = "DescriptionOfFirstAidMeasures", skip_serializing_if = "Option::is_none")]
950 pub description_of_first_aid_measures: Option<FirstAidMeasuresDescriptionOfFirstAidMeasures>,
951 #[serde(rename = "InformationToHealthProfessionals", skip_serializing_if = "Option::is_none")]
952 pub information_to_health_professionals: Option<FirstAidMeasuresInformationToHealthProfessionals>,
953 #[serde(rename = "MedicalAttentionAndSpecialTreatmentNeeded", skip_serializing_if = "Option::is_none")]
954 pub medical_attention_and_special_treatment_needed: Option<FirstAidMeasuresMedicalAttentionAndSpecialTreatmentNeeded>,
955 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
956 pub additional_info: Option<AdditionalInfo>,
957}
958
959#[derive(Debug, Clone, Serialize, Deserialize, Default)]
960pub struct FirstAidMeasuresDescriptionOfFirstAidMeasures {
961 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
962 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
963 pub full_text: Option<String>,
964 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
965 pub additional_info: Option<AdditionalInfo>,
966}
967
968#[derive(Debug, Clone, Serialize, Deserialize, Default)]
969pub struct FirstAidMeasuresExposureRoute {
970 #[serde(rename = "FirstAidInhalation", skip_serializing_if = "Option::is_none")]
971 pub first_aid_inhalation: Option<FirstAidMeasuresExposureRouteFirstAidInhalation>,
972 #[serde(rename = "FirstAidSkin", skip_serializing_if = "Option::is_none")]
973 pub first_aid_skin: Option<FirstAidMeasuresExposureRouteFirstAidSkin>,
974 #[serde(rename = "FirstAidEye", skip_serializing_if = "Option::is_none")]
975 pub first_aid_eye: Option<FirstAidMeasuresExposureRouteFirstAidEye>,
976 #[serde(rename = "FirstAidIngestion", skip_serializing_if = "Option::is_none")]
977 pub first_aid_ingestion: Option<FirstAidMeasuresExposureRouteFirstAidIngestion>,
978 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
979 pub additional_info: Option<AdditionalInfo>,
980}
981
982#[derive(Debug, Clone, Serialize, Deserialize, Default)]
983pub struct FirstAidMeasuresExposureRouteFirstAidEye {
984 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
985 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
986 pub full_text: Option<String>,
987 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
988 pub additional_info: Option<AdditionalInfo>,
989}
990
991#[derive(Debug, Clone, Serialize, Deserialize, Default)]
992pub struct FirstAidMeasuresExposureRouteFirstAidIngestion {
993 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
994 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
995 pub full_text: Option<String>,
996 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
997 pub additional_info: Option<AdditionalInfo>,
998}
999
1000#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1001pub struct FirstAidMeasuresExposureRouteFirstAidInhalation {
1002 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
1003 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1004 pub full_text: Option<String>,
1005 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1006 pub additional_info: Option<AdditionalInfo>,
1007}
1008
1009#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1010pub struct FirstAidMeasuresExposureRouteFirstAidSkin {
1011 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
1012 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1013 pub full_text: Option<String>,
1014 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1015 pub additional_info: Option<AdditionalInfo>,
1016}
1017
1018#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1019pub struct FirstAidMeasuresInformationToHealthProfessionals {
1020 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
1021 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1022 pub full_text: Option<String>,
1023 #[serde(rename = "AcuteSymptomsAndEffects", skip_serializing_if = "Option::is_none")]
1024 pub acute_symptoms_and_effects: Option<FirstAidMeasuresInformationToHealthProfessionalsAcuteSymptomsAndEffects>,
1025 #[serde(rename = "DelayedSymptomsAndEffects", skip_serializing_if = "Option::is_none")]
1026 pub delayed_symptoms_and_effects: Option<FirstAidMeasuresInformationToHealthProfessionalsDelayedSymptomsAndEffects>,
1027 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1028 pub additional_info: Option<AdditionalInfo>,
1029}
1030
1031#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1032pub struct FirstAidMeasuresInformationToHealthProfessionalsAcuteSymptomsAndEffects {
1033 #[serde(rename = "FirstAidInhalation", skip_serializing_if = "Option::is_none")]
1034 pub first_aid_inhalation: Option<Vec<String>>,
1035 #[serde(rename = "FirstAidEye", skip_serializing_if = "Option::is_none")]
1036 pub first_aid_eye: Option<Vec<String>>,
1037 #[serde(rename = "FirstAidSkin", skip_serializing_if = "Option::is_none")]
1038 pub first_aid_skin: Option<Vec<String>>,
1039 #[serde(rename = "FirstAidIngestion", skip_serializing_if = "Option::is_none")]
1040 pub first_aid_ingestion: Option<Vec<String>>,
1041 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1042 pub additional_info: Option<AdditionalInfo>,
1043}
1044
1045#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1046pub struct FirstAidMeasuresInformationToHealthProfessionalsDelayedSymptomsAndEffects {
1047 #[serde(rename = "FirstAidInhalation", skip_serializing_if = "Option::is_none")]
1048 pub first_aid_inhalation: Option<Vec<String>>,
1049 #[serde(rename = "FirstAidEye", skip_serializing_if = "Option::is_none")]
1050 pub first_aid_eye: Option<Vec<String>>,
1051 #[serde(rename = "FirstAidSkin", skip_serializing_if = "Option::is_none")]
1052 pub first_aid_skin: Option<Vec<String>>,
1053 #[serde(rename = "FirstAidIngestion", skip_serializing_if = "Option::is_none")]
1054 pub first_aid_ingestion: Option<Vec<String>>,
1055 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1056 pub additional_info: Option<AdditionalInfo>,
1057}
1058
1059#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1060pub struct FirstAidMeasuresMedicalAttentionAndSpecialTreatmentNeeded {
1061 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
1062 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1063 pub full_text: Option<String>,
1064 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1065 pub additional_info: Option<AdditionalInfo>,
1066}
1067
1068#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1069pub struct HandlingAndStorage {
1070 #[serde(rename = "SafeHandling", skip_serializing_if = "Option::is_none")]
1071 pub safe_handling: Option<HandlingAndStorageSafeHandling>,
1072 #[serde(rename = "Storage", skip_serializing_if = "Option::is_none")]
1073 pub storage: Option<HandlingAndStorageStorage>,
1074}
1075
1076#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1077pub struct HandlingAndStorageSafeHandling {
1078 #[serde(rename = "TechnicalMeasuresAndStorageConditions", skip_serializing_if = "Option::is_none")]
1079 pub technical_measures_and_storage_conditions: Option<HandlingAndStorageSafeHandlingTechnicalMeasuresAndStorageConditions>,
1080 #[serde(rename = "HandlingPrecautions", skip_serializing_if = "Option::is_none")]
1081 pub handling_precautions: Option<String>,
1082 #[serde(rename = "AvoidContact", skip_serializing_if = "Option::is_none")]
1083 pub avoid_contact: Option<String>,
1084 #[serde(rename = "HygienicMeasures", skip_serializing_if = "Option::is_none")]
1085 pub hygienic_measures: Option<String>,
1086 #[serde(rename = "AdditionalProcessingHazards", skip_serializing_if = "Option::is_none")]
1087 pub additional_processing_hazards: Option<String>,
1088 #[serde(rename = "FoodHygieneRegulations", skip_serializing_if = "Option::is_none")]
1089 pub food_hygiene_regulations: Option<String>,
1090 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1091 pub additional_info: Option<AdditionalInfo>,
1092}
1093
1094#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1095pub struct HandlingAndStorageSafeHandlingTechnicalMeasuresAndStorageConditions {
1096 #[serde(rename = "ProtectiveMeasures", skip_serializing_if = "Option::is_none")]
1097 pub protective_measures: Option<String>,
1098 #[serde(rename = "MeasuresToPreventFire", skip_serializing_if = "Option::is_none")]
1099 pub measures_to_prevent_fire: Option<String>,
1100 #[serde(rename = "GeneralOccupationalHygiene", skip_serializing_if = "Option::is_none")]
1101 pub general_occupational_hygiene: Option<String>,
1102 #[serde(rename = "VentilationCondition", skip_serializing_if = "Option::is_none")]
1103 pub ventilation_condition: Option<String>,
1104 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1105 pub additional_info: Option<AdditionalInfo>,
1106}
1107
1108#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1109pub struct HandlingAndStorageStorage {
1110 #[serde(rename = "ConditionsForSafeStorage", skip_serializing_if = "Option::is_none",
1111 default, deserialize_with = "crate::schema::serde_flex::flex_storage_conditions_opt")]
1112 pub conditions_for_safe_storage: Option<HandlingAndStorageStorageConditionsForSafeStorage>,
1113 #[serde(rename = "PackagingContainer", skip_serializing_if = "Option::is_none")]
1114 pub packaging_container: Option<String>,
1115 #[serde(rename = "SpecificEndUses", skip_serializing_if = "Option::is_none")]
1116 pub specific_end_uses: Option<String>,
1117 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1118 pub additional_info: Option<AdditionalInfo>,
1119}
1120
1121#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1122pub struct HandlingAndStorageStorageConditionsForSafeStorage {
1123 #[serde(rename = "TechnicalMeasuresAndStorageConditions", skip_serializing_if = "Option::is_none")]
1124 pub technical_measures_and_storage_conditions: Option<String>,
1125 #[serde(rename = "ConditionsToAvoid", skip_serializing_if = "Option::is_none")]
1126 pub conditions_to_avoid: Option<String>,
1127 #[serde(rename = "Conditions", skip_serializing_if = "Option::is_none")]
1128 pub conditions: Option<HandlingAndStorageStorageConditionsForSafeStorageConditions>,
1129 #[serde(rename = "StoragePrecautions", skip_serializing_if = "Option::is_none")]
1130 pub storage_precautions: Option<String>,
1131}
1132
1133#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1134pub struct HandlingAndStorageStorageConditionsForSafeStorageConditions {
1135 #[serde(rename = "MaximumStoragePeriod", skip_serializing_if = "Option::is_none")]
1136 pub maximum_storage_period: Option<String>,
1137 #[serde(rename = "StorageTemperature", skip_serializing_if = "Option::is_none")]
1138 pub storage_temperature: Option<String>,
1139 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1140 pub additional_info: Option<AdditionalInfo>,
1141}
1142
1143#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1144pub struct HazardIdentification {
1145 #[serde(rename = "Classification", skip_serializing_if = "Option::is_none")]
1146 pub classification: Option<HazardIdentificationClassification>,
1147 #[serde(rename = "HazardLabelling", skip_serializing_if = "Option::is_none")]
1148 pub hazard_labelling: Option<HazardIdentificationHazardLabelling>,
1149 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1150 pub additional_info: Option<AdditionalInfo>,
1151}
1152
1153#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1154pub struct HazardIdentificationClassification {
1155 #[serde(rename = "PhysicochemicalEffect", skip_serializing_if = "Option::is_none")]
1156 pub physicochemical_effect: Option<HazardIdentificationClassificationPhysicochemicalEffect>,
1157 #[serde(rename = "HealthEffect", skip_serializing_if = "Option::is_none")]
1158 pub health_effect: Option<HazardIdentificationClassificationHealthEffect>,
1159 #[serde(rename = "EnvironmentalEffect", skip_serializing_if = "Option::is_none")]
1160 pub environmental_effect: Option<HazardIdentificationClassificationEnvironmentalEffect>,
1161 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1162 pub additional_info: Option<AdditionalInfo>,
1163}
1164
1165#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1166pub struct HazardIdentificationClassificationEnvironmentalEffect {
1167 #[serde(rename = "AquaticToxicityAcute", skip_serializing_if = "Option::is_none")]
1168 pub aquatic_toxicity_acute: Option<String>,
1169 #[serde(rename = "AquaticToxicityChronic", skip_serializing_if = "Option::is_none")]
1170 pub aquatic_toxicity_chronic: Option<String>,
1171 #[serde(rename = "HazardousOzoneLayer", skip_serializing_if = "Option::is_none")]
1172 pub hazardous_ozone_layer: Option<String>,
1173 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1174 pub additional_info: Option<AdditionalInfo>,
1175}
1176
1177#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1178pub struct HazardIdentificationClassificationHealthEffect {
1179 #[serde(rename = "AcuteToxicityOral", skip_serializing_if = "Option::is_none")]
1180 pub acute_toxicity_oral: Option<String>,
1181 #[serde(rename = "AcuteToxicityDermal", skip_serializing_if = "Option::is_none")]
1182 pub acute_toxicity_dermal: Option<String>,
1183 #[serde(rename = "AcuteToxicityInhalationGas", skip_serializing_if = "Option::is_none")]
1184 pub acute_toxicity_inhalation_gas: Option<String>,
1185 #[serde(rename = "AcuteToxicityInhalationVapour", skip_serializing_if = "Option::is_none")]
1186 pub acute_toxicity_inhalation_vapour: Option<String>,
1187 #[serde(rename = "AcuteToxicityInhalationDustOrMist", skip_serializing_if = "Option::is_none")]
1188 pub acute_toxicity_inhalation_dust_or_mist: Option<String>,
1189 #[serde(rename = "SkinCorrosionIrritation", skip_serializing_if = "Option::is_none")]
1190 pub skin_corrosion_irritation: Option<String>,
1191 #[serde(rename = "EyeDamageOrIrritation", skip_serializing_if = "Option::is_none")]
1192 pub eye_damage_or_irritation: Option<String>,
1193 #[serde(rename = "RespiratorySensitisation", skip_serializing_if = "Option::is_none")]
1194 pub respiratory_sensitisation: Option<String>,
1195 #[serde(rename = "SkinSensitisation", skip_serializing_if = "Option::is_none")]
1196 pub skin_sensitisation: Option<String>,
1197 #[serde(rename = "GermCellMutagenicity", skip_serializing_if = "Option::is_none")]
1198 pub germ_cell_mutagenicity: Option<String>,
1199 #[serde(rename = "Carcinogenicity", skip_serializing_if = "Option::is_none")]
1200 pub carcinogenicity: Option<String>,
1201 #[serde(rename = "ReproductiveToxicity", skip_serializing_if = "Option::is_none")]
1202 pub reproductive_toxicity: Option<HazardIdentificationClassificationHealthEffectReproductiveToxicity>,
1203 #[serde(rename = "SpecificTargetOrganSE", skip_serializing_if = "Option::is_none",
1204 default, deserialize_with = "crate::schema::serde_flex::flex_stoase_opt")]
1205 pub specific_target_organ_se: Option<Vec<HazardIdentificationClassificationHealthEffectSpecificTargetOrganSE>>,
1206 #[serde(rename = "SpecificTargetOrganRE", skip_serializing_if = "Option::is_none",
1207 default, deserialize_with = "crate::schema::serde_flex::flex_stoare_opt")]
1208 pub specific_target_organ_re: Option<Vec<HazardIdentificationClassificationHealthEffectSpecificTargetOrganRE>>,
1209 #[serde(rename = "AspirationHazard", skip_serializing_if = "Option::is_none")]
1210 pub aspiration_hazard: Option<String>,
1211 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1212 pub additional_info: Option<AdditionalInfo>,
1213}
1214
1215#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1216pub struct HazardIdentificationClassificationHealthEffectReproductiveToxicity {
1217 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
1218 pub category: Option<String>,
1219 #[serde(rename = "Lactation", skip_serializing_if = "Option::is_none")]
1220 pub lactation: Option<String>,
1221}
1222
1223#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1224pub struct HazardIdentificationClassificationHealthEffectSpecificTargetOrganRE {
1225 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
1226 pub category: Option<String>,
1227 #[serde(rename = "TargetOrgan", skip_serializing_if = "Option::is_none")]
1228 pub target_organ: Option<Vec<String>>,
1229 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1230 pub additional_info: Option<AdditionalInfo>,
1231}
1232
1233#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1234pub struct HazardIdentificationClassificationHealthEffectSpecificTargetOrganSE {
1235 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
1236 pub category: Option<String>,
1237 #[serde(rename = "TargetOrgan", skip_serializing_if = "Option::is_none")]
1238 pub target_organ: Option<Vec<String>>,
1239 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1240 pub additional_info: Option<AdditionalInfo>,
1241}
1242
1243#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1244pub struct HazardIdentificationClassificationPhysicochemicalEffect {
1245 #[serde(rename = "Explosives", skip_serializing_if = "Option::is_none")]
1246 pub explosives: Option<String>,
1247 #[serde(rename = "FlammableGases", skip_serializing_if = "Option::is_none")]
1248 pub flammable_gases: Option<String>,
1249 #[serde(rename = "FlammableAerosols", skip_serializing_if = "Option::is_none")]
1250 pub flammable_aerosols: Option<String>,
1251 #[serde(rename = "OxidisingGases", skip_serializing_if = "Option::is_none")]
1252 pub oxidising_gases: Option<String>,
1253 #[serde(rename = "GasesUnderPressure", skip_serializing_if = "Option::is_none")]
1254 pub gases_under_pressure: Option<String>,
1255 #[serde(rename = "FlammableLiquids", skip_serializing_if = "Option::is_none")]
1256 pub flammable_liquids: Option<String>,
1257 #[serde(rename = "FlammableSolids", skip_serializing_if = "Option::is_none")]
1258 pub flammable_solids: Option<String>,
1259 #[serde(rename = "SelfreactiveSubstancesAndMixtures", skip_serializing_if = "Option::is_none")]
1260 pub selfreactive_substances_and_mixtures: Option<String>,
1261 #[serde(rename = "PyrophoricLiquids", skip_serializing_if = "Option::is_none")]
1262 pub pyrophoric_liquids: Option<String>,
1263 #[serde(rename = "PyrophoricSolids", skip_serializing_if = "Option::is_none")]
1264 pub pyrophoric_solids: Option<String>,
1265 #[serde(rename = "SelfheatingSubstancesAndMixtures", skip_serializing_if = "Option::is_none")]
1266 pub selfheating_substances_and_mixtures: Option<String>,
1267 #[serde(rename = "SubstancesWhichInContactWithWaterEmitFlammableGases", skip_serializing_if = "Option::is_none")]
1268 pub substances_which_in_contact_with_water_emit_flammable_gases: Option<String>,
1269 #[serde(rename = "OxidisingLiquids", skip_serializing_if = "Option::is_none")]
1270 pub oxidising_liquids: Option<String>,
1271 #[serde(rename = "OxidisingSolids", skip_serializing_if = "Option::is_none")]
1272 pub oxidising_solids: Option<String>,
1273 #[serde(rename = "OrganicPeroxides", skip_serializing_if = "Option::is_none")]
1274 pub organic_peroxides: Option<String>,
1275 #[serde(rename = "CorrosiveToMetals", skip_serializing_if = "Option::is_none")]
1276 pub corrosive_to_metals: Option<String>,
1277 #[serde(rename = "DesensitizedExplosives", skip_serializing_if = "Option::is_none")]
1278 pub desensitized_explosives: Option<String>,
1279 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1280 pub additional_info: Option<AdditionalInfo>,
1281}
1282
1283#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1284pub struct HazardIdentificationHazardLabelling {
1285 #[serde(rename = "HazardPictogram", skip_serializing_if = "Option::is_none")]
1286 pub hazard_pictogram: Option<Vec<String>>,
1287 #[serde(rename = "SignalWord", skip_serializing_if = "Option::is_none")]
1288 pub signal_word: Option<String>,
1289 #[serde(rename = "HazardStatement", skip_serializing_if = "Option::is_none")]
1290 pub hazard_statement: Option<Vec<HazardIdentificationHazardLabellingHazardStatement>>,
1291 #[serde(rename = "PrecautionaryStatements", skip_serializing_if = "Option::is_none")]
1292 pub precautionary_statements: Option<HazardIdentificationHazardLabellingPrecautionaryStatements>,
1293 #[serde(rename = "OtherHazardsInfo", skip_serializing_if = "Option::is_none")]
1294 pub other_hazards_info: Option<HazardIdentificationHazardLabellingOtherHazardsInfo>,
1295 #[serde(rename = "SignificantIndicatorsAndEmergencyOverview", skip_serializing_if = "Option::is_none")]
1296 pub significant_indicators_and_emergency_overview: Option<HazardIdentificationHazardLabellingSignificantIndicatorsAndEmergencyOverview>,
1297 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1298 pub additional_info: Option<AdditionalInfo>,
1299}
1300
1301#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1302pub struct HazardIdentificationHazardLabellingHazardStatement {
1303 #[serde(rename = "HazardStatementCode", skip_serializing_if = "Option::is_none")]
1304 pub hazard_statement_code: Option<String>,
1305 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
1306 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1307 pub full_text: Option<String>,
1308}
1309
1310#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1311pub struct HazardIdentificationHazardLabellingOtherHazardsInfo {
1312 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
1313 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1314 pub full_text: Option<String>,
1315 #[serde(rename = "PhysicochemicalEffect", skip_serializing_if = "Option::is_none")]
1316 pub physicochemical_effect: Option<String>,
1317 #[serde(rename = "HealthEffect", skip_serializing_if = "Option::is_none")]
1318 pub health_effect: Option<String>,
1319 #[serde(rename = "EnvironmentalEffect", skip_serializing_if = "Option::is_none")]
1320 pub environmental_effect: Option<String>,
1321 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1322 pub additional_info: Option<AdditionalInfo>,
1323}
1324
1325#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1326pub struct HazardIdentificationHazardLabellingPrecautionaryStatements {
1327 #[serde(rename = "Prevention", skip_serializing_if = "Option::is_none")]
1328 pub prevention: Option<Vec<HazardIdentificationHazardLabellingPrecautionaryStatementsPrevention>>,
1329 #[serde(rename = "Response", skip_serializing_if = "Option::is_none")]
1330 pub response: Option<Vec<HazardIdentificationHazardLabellingPrecautionaryStatementsResponse>>,
1331 #[serde(rename = "Storage", skip_serializing_if = "Option::is_none")]
1332 pub storage: Option<Vec<HazardIdentificationHazardLabellingPrecautionaryStatementsStorage>>,
1333 #[serde(rename = "Disposal", skip_serializing_if = "Option::is_none")]
1334 pub disposal: Option<Vec<HazardIdentificationHazardLabellingPrecautionaryStatementsDisposal>>,
1335 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1336 pub additional_info: Option<AdditionalInfo>,
1337}
1338
1339#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1340pub struct HazardIdentificationHazardLabellingPrecautionaryStatementsDisposal {
1341 #[serde(rename = "PrecautionaryStatementCode", skip_serializing_if = "Option::is_none")]
1342 pub precautionary_statement_code: Option<String>,
1343 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
1344 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1345 pub full_text: Option<String>,
1346}
1347
1348#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1349pub struct HazardIdentificationHazardLabellingPrecautionaryStatementsPrevention {
1350 #[serde(rename = "PrecautionaryStatementCode", skip_serializing_if = "Option::is_none")]
1351 pub precautionary_statement_code: Option<String>,
1352 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
1353 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1354 pub full_text: Option<String>,
1355}
1356
1357#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1358pub struct HazardIdentificationHazardLabellingPrecautionaryStatementsResponse {
1359 #[serde(rename = "PrecautionaryStatementCode", skip_serializing_if = "Option::is_none")]
1360 pub precautionary_statement_code: Option<String>,
1361 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
1362 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1363 pub full_text: Option<String>,
1364}
1365
1366#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1367pub struct HazardIdentificationHazardLabellingPrecautionaryStatementsStorage {
1368 #[serde(rename = "PrecautionaryStatementCode", skip_serializing_if = "Option::is_none")]
1369 pub precautionary_statement_code: Option<String>,
1370 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
1371 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1372 pub full_text: Option<String>,
1373}
1374
1375#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1376pub struct HazardIdentificationHazardLabellingSignificantIndicatorsAndEmergencyOverview {
1377 #[serde(rename = "SignificantIndicators", skip_serializing_if = "Option::is_none")]
1378 pub significant_indicators: Option<String>,
1379 #[serde(rename = "EmergencyOverview", skip_serializing_if = "Option::is_none")]
1380 pub emergency_overview: Option<String>,
1381 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1382 pub additional_info: Option<AdditionalInfo>,
1383}
1384
1385#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1386pub struct Identification {
1387 #[serde(rename = "TradeProductIdentity", skip_serializing_if = "Option::is_none")]
1388 pub trade_product_identity: Option<IdentificationTradeProductIdentity>,
1389 #[serde(rename = "SpecificationNo", skip_serializing_if = "Option::is_none")]
1390 pub specification_no: Option<Vec<String>>,
1391 #[serde(rename = "SupplierInformation", skip_serializing_if = "Option::is_none")]
1392 pub supplier_information: Option<IdentificationSupplierInformation>,
1393 #[serde(rename = "UseAndUseAdvisedAgainst", skip_serializing_if = "Option::is_none")]
1394 pub use_and_use_advised_against: Option<IdentificationUseAndUseAdvisedAgainst>,
1395 #[serde(rename = "DomesticManufacturerInformation", skip_serializing_if = "Option::is_none")]
1396 pub domestic_manufacturer_information: Option<IdentificationDomesticManufacturerInformation>,
1397 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1398 pub additional_info: Option<AdditionalInfo>,
1399}
1400
1401#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1402pub struct IdentificationDomesticManufacturerInformation {
1403 #[serde(rename = "CompanyName", skip_serializing_if = "Option::is_none")]
1404 pub company_name: Option<String>,
1405 #[serde(rename = "Department", skip_serializing_if = "Option::is_none")]
1406 pub department: Option<String>,
1407 #[serde(rename = "Name", skip_serializing_if = "Option::is_none")]
1408 pub name: Option<String>,
1409 #[serde(rename = "PostCode", skip_serializing_if = "Option::is_none")]
1410 pub post_code: Option<String>,
1411 #[serde(rename = "Address", skip_serializing_if = "Option::is_none")]
1412 pub address: Option<String>,
1413 #[serde(rename = "Phone", skip_serializing_if = "Option::is_none")]
1414 pub phone: Option<String>,
1415 #[serde(rename = "WorkingHours", skip_serializing_if = "Option::is_none")]
1416 pub working_hours: Option<String>,
1417 #[serde(rename = "Fax", skip_serializing_if = "Option::is_none")]
1418 pub fax: Option<String>,
1419 #[serde(rename = "Email", skip_serializing_if = "Option::is_none")]
1420 pub email: Option<String>,
1421 #[serde(rename = "CompanyUrl", skip_serializing_if = "Option::is_none")]
1422 pub company_url: Option<String>,
1423 #[serde(rename = "EmergencyContact", skip_serializing_if = "Option::is_none")]
1424 pub emergency_contact: Option<Vec<IdentificationDomesticManufacturerInformationEmergencyContact>>,
1425 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1426 pub additional_info: Option<AdditionalInfo>,
1427}
1428
1429#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1430pub struct IdentificationDomesticManufacturerInformationEmergencyContact {
1431 #[serde(rename = "CompanyName", skip_serializing_if = "Option::is_none")]
1432 pub company_name: Option<String>,
1433 #[serde(rename = "Department", skip_serializing_if = "Option::is_none")]
1434 pub department: Option<String>,
1435 #[serde(rename = "Name", skip_serializing_if = "Option::is_none")]
1436 pub name: Option<String>,
1437 #[serde(rename = "PostCode", skip_serializing_if = "Option::is_none")]
1438 pub post_code: Option<String>,
1439 #[serde(rename = "Address", skip_serializing_if = "Option::is_none")]
1440 pub address: Option<String>,
1441 #[serde(rename = "Phone", skip_serializing_if = "Option::is_none")]
1442 pub phone: Option<String>,
1443 #[serde(rename = "WorkingHours", skip_serializing_if = "Option::is_none")]
1444 pub working_hours: Option<String>,
1445 #[serde(rename = "Fax", skip_serializing_if = "Option::is_none")]
1446 pub fax: Option<String>,
1447 #[serde(rename = "Email", skip_serializing_if = "Option::is_none")]
1448 pub email: Option<String>,
1449 #[serde(rename = "CompanyUrl", skip_serializing_if = "Option::is_none")]
1450 pub company_url: Option<String>,
1451 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1452 pub additional_info: Option<AdditionalInfo>,
1453}
1454
1455#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1456pub struct IdentificationSupplierInformation {
1457 #[serde(rename = "CompanyName", skip_serializing_if = "Option::is_none")]
1458 pub company_name: Option<String>,
1459 #[serde(rename = "Department", skip_serializing_if = "Option::is_none")]
1460 pub department: Option<String>,
1461 #[serde(rename = "Name", skip_serializing_if = "Option::is_none")]
1462 pub name: Option<String>,
1463 #[serde(rename = "PostCode", skip_serializing_if = "Option::is_none")]
1464 pub post_code: Option<String>,
1465 #[serde(rename = "Address", skip_serializing_if = "Option::is_none")]
1466 pub address: Option<String>,
1467 #[serde(rename = "Phone", skip_serializing_if = "Option::is_none")]
1468 pub phone: Option<String>,
1469 #[serde(rename = "WorkingHours", skip_serializing_if = "Option::is_none")]
1470 pub working_hours: Option<String>,
1471 #[serde(rename = "Fax", skip_serializing_if = "Option::is_none")]
1472 pub fax: Option<String>,
1473 #[serde(rename = "Email", skip_serializing_if = "Option::is_none")]
1474 pub email: Option<String>,
1475 #[serde(rename = "CompanyUrl", skip_serializing_if = "Option::is_none")]
1476 pub company_url: Option<String>,
1477 #[serde(rename = "EmergencyContact", skip_serializing_if = "Option::is_none")]
1478 pub emergency_contact: Option<Vec<IdentificationSupplierInformationEmergencyContact>>,
1479 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1480 pub additional_info: Option<AdditionalInfo>,
1481}
1482
1483#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1484pub struct IdentificationSupplierInformationEmergencyContact {
1485 #[serde(rename = "CompanyName", skip_serializing_if = "Option::is_none")]
1486 pub company_name: Option<String>,
1487 #[serde(rename = "Department", skip_serializing_if = "Option::is_none")]
1488 pub department: Option<String>,
1489 #[serde(rename = "Name", skip_serializing_if = "Option::is_none")]
1490 pub name: Option<String>,
1491 #[serde(rename = "PostCode", skip_serializing_if = "Option::is_none")]
1492 pub post_code: Option<String>,
1493 #[serde(rename = "Address", skip_serializing_if = "Option::is_none")]
1494 pub address: Option<String>,
1495 #[serde(rename = "Phone", skip_serializing_if = "Option::is_none")]
1496 pub phone: Option<String>,
1497 #[serde(rename = "WorkingHours", skip_serializing_if = "Option::is_none")]
1498 pub working_hours: Option<String>,
1499 #[serde(rename = "Fax", skip_serializing_if = "Option::is_none")]
1500 pub fax: Option<String>,
1501 #[serde(rename = "Email", skip_serializing_if = "Option::is_none")]
1502 pub email: Option<String>,
1503 #[serde(rename = "CompanyUrl", skip_serializing_if = "Option::is_none")]
1504 pub company_url: Option<String>,
1505 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1506 pub additional_info: Option<AdditionalInfo>,
1507}
1508
1509#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1510pub struct IdentificationTradeProductIdentity {
1511 #[serde(rename = "TradeNameJP", skip_serializing_if = "Option::is_none")]
1512 pub trade_name_jp: Option<String>,
1513 #[serde(rename = "TradeNameEN", skip_serializing_if = "Option::is_none")]
1514 pub trade_name_en: Option<String>,
1515 #[serde(rename = "OtherName", skip_serializing_if = "Option::is_none")]
1516 pub other_name: Option<Vec<String>>,
1517 #[serde(rename = "ProductNoUser", skip_serializing_if = "Option::is_none")]
1518 pub product_no_user: Option<Vec<String>>,
1519 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1520 pub additional_info: Option<AdditionalInfo>,
1521}
1522
1523#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1524pub struct IdentificationUseAndUseAdvisedAgainst {
1525 #[serde(rename = "Use", skip_serializing_if = "Option::is_none")]
1526 pub r#use: Option<Vec<String>>,
1527 #[serde(rename = "UseAdvisedAgainst", skip_serializing_if = "Option::is_none")]
1528 pub use_advised_against: Option<Vec<String>>,
1529 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1530 pub additional_info: Option<AdditionalInfo>,
1531}
1532
1533#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1534pub struct OtherInformation {
1535 #[serde(rename = "RelatedDocuments", skip_serializing_if = "Option::is_none")]
1536 pub related_documents: Option<String>,
1537 #[serde(rename = "RevisionInformation", skip_serializing_if = "Option::is_none")]
1538 pub revision_information: Option<Vec<OtherInformationRevisionInformation>>,
1539 #[serde(rename = "Desclaimer", skip_serializing_if = "Option::is_none")]
1540 pub desclaimer: Option<String>,
1541 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1542 pub additional_info: Option<AdditionalInfo>,
1543}
1544
1545#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1546pub struct OtherInformationRevisionInformation {
1547 #[serde(rename = "LastUpdateDate", skip_serializing_if = "Option::is_none")]
1548 pub last_update_date: Option<String>,
1549 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
1550 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1551 pub full_text: Option<String>,
1552}
1553
1554#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1555pub struct PhysicalChemicalProperties {
1556 #[serde(rename = "BasePhysicalChemicalProperties", skip_serializing_if = "Option::is_none")]
1557 pub base_physical_chemical_properties: Option<PhysicalChemicalPropertiesBasePhysicalChemicalProperties>,
1558 #[serde(rename = "MeltingPointRelated", skip_serializing_if = "Option::is_none")]
1559 pub melting_point_related: Option<Vec<PhysicalChemicalPropertiesMeltingPointRelated>>,
1560 #[serde(rename = "BoilingPointRelated", skip_serializing_if = "Option::is_none")]
1561 pub boiling_point_related: Option<Vec<PhysicalChemicalPropertiesBoilingPointRelated>>,
1562 #[serde(rename = "Flammability", skip_serializing_if = "Option::is_none",
1563 default, deserialize_with = "crate::schema::serde_flex::flex_vec_string_or_obj_opt")]
1564 pub flammability: Option<Vec<String>>,
1565 #[serde(rename = "ExplosionLimit", skip_serializing_if = "Option::is_none")]
1566 pub explosion_limit: Option<Vec<PhysicalChemicalPropertiesExplosionLimit>>,
1567 #[serde(rename = "FlashPoint", skip_serializing_if = "Option::is_none")]
1568 pub flash_point: Option<Vec<PhysicalChemicalPropertiesFlashPoint>>,
1569 #[serde(rename = "AutoignitionTemperature", skip_serializing_if = "Option::is_none")]
1570 pub autoignition_temperature: Option<Vec<PhysicalChemicalPropertiesAutoignitionTemperature>>,
1571 #[serde(rename = "DecompositionTemperature", skip_serializing_if = "Option::is_none")]
1572 pub decomposition_temperature: Option<Vec<PhysicalChemicalPropertiesDecompositionTemperature>>,
1573 #[serde(rename = "PhValue", skip_serializing_if = "Option::is_none")]
1574 pub ph_value: Option<Vec<PhysicalChemicalPropertiesPhValue>>,
1575 #[serde(rename = "DynamicViscosity", skip_serializing_if = "Option::is_none")]
1576 pub dynamic_viscosity: Option<Vec<PhysicalChemicalPropertiesDynamicViscosity>>,
1577 #[serde(rename = "Solubilities", skip_serializing_if = "Option::is_none")]
1578 pub solubilities: Option<PhysicalChemicalPropertiesSolubilities>,
1579 #[serde(rename = "PartitionCoefficient", skip_serializing_if = "Option::is_none")]
1580 pub partition_coefficient: Option<Vec<PhysicalChemicalPropertiesPartitionCoefficient>>,
1581 #[serde(rename = "VapourPressure", skip_serializing_if = "Option::is_none")]
1582 pub vapour_pressure: Option<Vec<PhysicalChemicalPropertiesVapourPressure>>,
1583 #[serde(rename = "Densities", skip_serializing_if = "Option::is_none")]
1584 pub densities: Option<Vec<PhysicalChemicalPropertiesDensities>>,
1585 #[serde(rename = "RelativeVapourDensity", skip_serializing_if = "Option::is_none")]
1586 pub relative_vapour_density: Option<Vec<PhysicalChemicalPropertiesRelativeVapourDensity>>,
1587 #[serde(rename = "ParticleSize", skip_serializing_if = "Option::is_none")]
1588 pub particle_size: Option<PhysicalChemicalPropertiesParticleSize>,
1589 #[serde(rename = "Radioactivity", skip_serializing_if = "Option::is_none")]
1590 pub radioactivity: Option<Vec<PhysicalChemicalPropertiesRadioactivity>>,
1591 #[serde(rename = "BulkDensity", skip_serializing_if = "Option::is_none")]
1592 pub bulk_density: Option<Vec<PhysicalChemicalPropertiesBulkDensity>>,
1593 #[serde(rename = "BurningPersistence", skip_serializing_if = "Option::is_none")]
1594 pub burning_persistence: Option<Vec<PhysicalChemicalPropertiesBurningPersistence>>,
1595 #[serde(rename = "OtherPhysicalChemicalProperty", skip_serializing_if = "Option::is_none")]
1596 pub other_physical_chemical_property: Option<Vec<PhysicalChemicalPropertiesOtherPhysicalChemicalProperty>>,
1597 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1598 pub additional_info: Option<AdditionalInfo>,
1599}
1600
1601#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1602pub struct PhysicalChemicalPropertiesAutoignitionTemperature {
1603 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1604 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1605 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1606 pub method: Option<String>,
1607 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none",
1608 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1609 pub condition: Option<String>,
1610 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1611 pub additional_info: Option<AdditionalInfo>,
1612}
1613
1614#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1615pub struct PhysicalChemicalPropertiesBasePhysicalChemicalProperties {
1616 #[serde(rename = "PhysicalState", skip_serializing_if = "Option::is_none")]
1617 pub physical_state: Option<String>,
1618 #[serde(rename = "Colour", skip_serializing_if = "Option::is_none")]
1619 pub colour: Option<String>,
1620 #[serde(rename = "Odour", skip_serializing_if = "Option::is_none")]
1621 pub odour: Option<String>,
1622 #[serde(rename = "OdourThreshold", skip_serializing_if = "Option::is_none")]
1623 pub odour_threshold: Option<PhysicalChemicalPropertiesBasePhysicalChemicalPropertiesOdourThreshold>,
1624 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1625 pub additional_info: Option<AdditionalInfo>,
1626}
1627
1628#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1629pub struct PhysicalChemicalPropertiesBasePhysicalChemicalPropertiesOdourThreshold {
1630 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1631 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1632 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1633 pub additional_info: Option<AdditionalInfo>,
1634}
1635
1636#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1637pub struct PhysicalChemicalPropertiesBoilingPointRelated {
1638 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
1639 pub item_name: Option<String>,
1640 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1641 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1642 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1643 pub method: Option<String>,
1644 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none")]
1645 pub condition: Option<PhysicalChemicalPropertiesBoilingPointRelatedCondition>,
1646 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1647 pub additional_info: Option<AdditionalInfo>,
1648}
1649
1650#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1651pub struct PhysicalChemicalPropertiesBoilingPointRelatedCondition {
1652 #[serde(rename = "PressureValue", skip_serializing_if = "Option::is_none")]
1653 pub pressure_value: Option<f64>,
1654 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
1655 pub unit: Option<String>,
1656 #[serde(rename = "OtherCondition", skip_serializing_if = "Option::is_none")]
1657 pub other_condition: Option<String>,
1658}
1659
1660#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1661pub struct PhysicalChemicalPropertiesBulkDensity {
1662 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1663 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1664 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1665 pub method: Option<String>,
1666 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none",
1667 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1668 pub condition: Option<String>,
1669 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1670 pub additional_info: Option<AdditionalInfo>,
1671}
1672
1673#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1674pub struct PhysicalChemicalPropertiesBurningPersistence {
1675 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1676 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1677 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1678 pub method: Option<String>,
1679 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none",
1680 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1681 pub condition: Option<String>,
1682 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1683 pub additional_info: Option<AdditionalInfo>,
1684}
1685
1686#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1687pub struct PhysicalChemicalPropertiesDecompositionTemperature {
1688 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1689 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1690 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1691 pub method: Option<String>,
1692 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none",
1693 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1694 pub condition: Option<String>,
1695 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1696 pub additional_info: Option<AdditionalInfo>,
1697}
1698
1699#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1700pub struct PhysicalChemicalPropertiesDensities {
1701 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
1702 pub item_name: Option<String>,
1703 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1704 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1705 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1706 pub method: Option<String>,
1707 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none",
1708 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1709 pub condition: Option<String>,
1710 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1711 pub additional_info: Option<AdditionalInfo>,
1712}
1713
1714#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1715pub struct PhysicalChemicalPropertiesDynamicViscosity {
1716 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
1717 pub item_name: Option<String>,
1718 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1719 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1720 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1721 pub method: Option<String>,
1722 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none")]
1723 pub condition: Option<PhysicalChemicalPropertiesDynamicViscosityCondition>,
1724 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1725 pub additional_info: Option<AdditionalInfo>,
1726}
1727
1728#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1729pub struct PhysicalChemicalPropertiesDynamicViscosityCondition {
1730 #[serde(rename = "Temperature", skip_serializing_if = "Option::is_none")]
1731 pub temperature: Option<f64>,
1732 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
1733 pub unit: Option<String>,
1734 #[serde(rename = "OtherCondition", skip_serializing_if = "Option::is_none")]
1735 pub other_condition: Option<String>,
1736}
1737
1738#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1739pub struct PhysicalChemicalPropertiesExplosionLimit {
1740 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
1741 pub item_name: Option<String>,
1742 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1743 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1744 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1745 pub method: Option<String>,
1746 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none",
1747 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1748 pub condition: Option<String>,
1749 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1750 pub additional_info: Option<AdditionalInfo>,
1751}
1752
1753#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1754pub struct PhysicalChemicalPropertiesFlashPoint {
1755 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1756 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1757 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1758 pub method: Option<String>,
1759 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none",
1760 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1761 pub condition: Option<String>,
1762 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1763 pub additional_info: Option<AdditionalInfo>,
1764}
1765
1766#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1767pub struct PhysicalChemicalPropertiesMeltingPointRelated {
1768 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
1769 pub item_name: Option<String>,
1770 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1771 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1772 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1773 pub method: Option<String>,
1774 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none")]
1775 pub condition: Option<PhysicalChemicalPropertiesMeltingPointRelatedCondition>,
1776 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1777 pub additional_info: Option<AdditionalInfo>,
1778}
1779
1780#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1781pub struct PhysicalChemicalPropertiesMeltingPointRelatedCondition {
1782 #[serde(rename = "PressureValue", skip_serializing_if = "Option::is_none")]
1783 pub pressure_value: Option<f64>,
1784 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
1785 pub unit: Option<String>,
1786 #[serde(rename = "OtherCondition", skip_serializing_if = "Option::is_none")]
1787 pub other_condition: Option<String>,
1788}
1789
1790#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1791pub struct PhysicalChemicalPropertiesOtherPhysicalChemicalProperty {
1792 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
1793 pub item_name: Option<String>,
1794 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1795 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1796 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1797 pub method: Option<String>,
1798 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none",
1799 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1800 pub condition: Option<String>,
1801 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1802 pub additional_info: Option<AdditionalInfo>,
1803}
1804
1805#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1806pub struct PhysicalChemicalPropertiesParticleSize {
1807 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
1808 pub item_name: Option<Vec<PhysicalChemicalPropertiesParticleSizeItemName>>,
1809 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1810 pub additional_info: Option<AdditionalInfo>,
1811}
1812
1813#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1814pub struct PhysicalChemicalPropertiesParticleSizeItemName {
1815 #[serde(rename = "ItemName", skip_serializing_if = "Option::is_none")]
1816 pub item_name: Option<String>,
1817 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1818 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1819 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1820 pub method: Option<String>,
1821 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none",
1822 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1823 pub condition: Option<String>,
1824 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1825 pub additional_info: Option<AdditionalInfo>,
1826}
1827
1828#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1829pub struct PhysicalChemicalPropertiesPartitionCoefficient {
1830 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1831 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1832 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1833 pub method: Option<String>,
1834 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none")]
1835 pub condition: Option<PhysicalChemicalPropertiesPartitionCoefficientCondition>,
1836 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1837 pub additional_info: Option<AdditionalInfo>,
1838}
1839
1840#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1841pub struct PhysicalChemicalPropertiesPartitionCoefficientCondition {
1842 #[serde(rename = "Temperature", skip_serializing_if = "Option::is_none")]
1843 pub temperature: Option<f64>,
1844 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
1845 pub unit: Option<String>,
1846 #[serde(rename = "OtherCondition", skip_serializing_if = "Option::is_none")]
1847 pub other_condition: Option<String>,
1848}
1849
1850#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1851pub struct PhysicalChemicalPropertiesPhValue {
1852 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1853 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1854 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1855 pub method: Option<String>,
1856 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none")]
1857 pub condition: Option<PhysicalChemicalPropertiesPhValueCondition>,
1858 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1859 pub additional_info: Option<AdditionalInfo>,
1860}
1861
1862#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1863pub struct PhysicalChemicalPropertiesPhValueCondition {
1864 #[serde(rename = "Temperature", skip_serializing_if = "Option::is_none")]
1865 pub temperature: Option<f64>,
1866 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
1867 pub unit: Option<String>,
1868 #[serde(rename = "OtherCondition", skip_serializing_if = "Option::is_none")]
1869 pub other_condition: Option<String>,
1870}
1871
1872#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1873pub struct PhysicalChemicalPropertiesRadioactivity {
1874 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1875 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1876 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1877 pub method: Option<String>,
1878 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none",
1879 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1880 pub condition: Option<String>,
1881 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1882 pub additional_info: Option<AdditionalInfo>,
1883}
1884
1885#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1886pub struct PhysicalChemicalPropertiesRelativeVapourDensity {
1887 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1888 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1889 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1890 pub method: Option<String>,
1891 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none",
1892 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
1893 pub condition: Option<String>,
1894 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1895 pub additional_info: Option<AdditionalInfo>,
1896}
1897
1898#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1899pub struct PhysicalChemicalPropertiesSolubilities {
1900 #[serde(rename = "WaterSolubility", skip_serializing_if = "Option::is_none")]
1901 pub water_solubility: Option<Vec<PhysicalChemicalPropertiesSolubilitiesWaterSolubility>>,
1902 #[serde(rename = "OtherSolubility", skip_serializing_if = "Option::is_none")]
1903 pub other_solubility: Option<Vec<PhysicalChemicalPropertiesSolubilitiesOtherSolubility>>,
1904 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1905 pub additional_info: Option<AdditionalInfo>,
1906}
1907
1908#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1909pub struct PhysicalChemicalPropertiesSolubilitiesOtherSolubility {
1910 #[serde(rename = "Solvent", skip_serializing_if = "Option::is_none")]
1911 pub solvent: Option<String>,
1912 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1913 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1914 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1915 pub method: Option<String>,
1916 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none")]
1917 pub condition: Option<PhysicalChemicalPropertiesSolubilitiesOtherSolubilityCondition>,
1918 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1919 pub additional_info: Option<AdditionalInfo>,
1920}
1921
1922#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1923pub struct PhysicalChemicalPropertiesSolubilitiesOtherSolubilityCondition {
1924 #[serde(rename = "Temperature", skip_serializing_if = "Option::is_none")]
1925 pub temperature: Option<f64>,
1926 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
1927 pub unit: Option<String>,
1928 #[serde(rename = "OtherCondition", skip_serializing_if = "Option::is_none")]
1929 pub other_condition: Option<String>,
1930}
1931
1932#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1933pub struct PhysicalChemicalPropertiesSolubilitiesWaterSolubility {
1934 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1935 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1936 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1937 pub method: Option<String>,
1938 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none")]
1939 pub condition: Option<PhysicalChemicalPropertiesSolubilitiesWaterSolubilityCondition>,
1940 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1941 pub additional_info: Option<AdditionalInfo>,
1942}
1943
1944#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1945pub struct PhysicalChemicalPropertiesSolubilitiesWaterSolubilityCondition {
1946 #[serde(rename = "Temperature", skip_serializing_if = "Option::is_none")]
1947 pub temperature: Option<f64>,
1948 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
1949 pub unit: Option<String>,
1950 #[serde(rename = "OtherCondition", skip_serializing_if = "Option::is_none")]
1951 pub other_condition: Option<String>,
1952}
1953
1954#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1955pub struct PhysicalChemicalPropertiesVapourPressure {
1956 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
1957 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
1958 #[serde(rename = "Method", skip_serializing_if = "Option::is_none")]
1959 pub method: Option<String>,
1960 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none")]
1961 pub condition: Option<PhysicalChemicalPropertiesVapourPressureCondition>,
1962 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1963 pub additional_info: Option<AdditionalInfo>,
1964}
1965
1966#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1967pub struct PhysicalChemicalPropertiesVapourPressureCondition {
1968 #[serde(rename = "Temperature", skip_serializing_if = "Option::is_none")]
1969 pub temperature: Option<f64>,
1970 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
1971 pub unit: Option<String>,
1972 #[serde(rename = "OtherCondition", skip_serializing_if = "Option::is_none")]
1973 pub other_condition: Option<String>,
1974}
1975
1976#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1977pub struct RegulatoryInformation {
1978 #[serde(rename = "PRTRLaw", skip_serializing_if = "Option::is_none")]
1979 pub prtr_law: Option<RegulatoryInformationPRTRLaw>,
1980 #[serde(rename = "ISHA", skip_serializing_if = "Option::is_none")]
1981 pub isha: Option<RegulatoryInformationISHA>,
1982 #[serde(rename = "PDSCA", skip_serializing_if = "Option::is_none")]
1983 pub pdsca: Option<RegulatoryInformationPDSCA>,
1984 #[serde(rename = "OtherLegislation", skip_serializing_if = "Option::is_none")]
1985 pub other_legislation: Option<RegulatoryInformationOtherLegislation>,
1986 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1987 pub additional_info: Option<AdditionalInfo>,
1988}
1989
1990#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1991pub struct RegulatoryInformationISHA {
1992 #[serde(rename = "ISHAregulation", skip_serializing_if = "Option::is_none")]
1993 pub ish_aregulation: Option<Vec<RegulatoryInformationISHAISHAregulation>>,
1994 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
1995 pub additional_info: Option<AdditionalInfo>,
1996}
1997
1998#[derive(Debug, Clone, Serialize, Deserialize, Default)]
1999pub struct RegulatoryInformationISHAISHAregulation {
2000 #[serde(rename = "RegulationName", skip_serializing_if = "Option::is_none")]
2001 pub regulation_name: Option<String>,
2002 #[serde(rename = "Composition", skip_serializing_if = "Option::is_none")]
2003 pub composition: Option<Vec<RegulatoryInformationISHAISHAregulationComposition>>,
2004 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2005 pub additional_info: Option<AdditionalInfo>,
2006}
2007
2008#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2009pub struct RegulatoryInformationISHAISHAregulationComposition {
2010 #[serde(rename = "SubstanceIdentifiers", skip_serializing_if = "Option::is_none")]
2011 pub substance_identifiers: Option<SubstanceIdentifiers>,
2012 #[serde(rename = "Classification", skip_serializing_if = "Option::is_none")]
2013 pub classification: Option<String>,
2014 #[serde(rename = "isApplicable", skip_serializing_if = "Option::is_none")]
2015 pub is_applicable: Option<bool>,
2016 #[serde(rename = "ImplementationDate", skip_serializing_if = "Option::is_none")]
2017 pub implementation_date: Option<String>,
2018 #[serde(rename = "Concentration", skip_serializing_if = "Option::is_none")]
2019 pub concentration: Option<RegulatoryInformationISHAISHAregulationCompositionConcentration>,
2020 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2021 pub additional_info: Option<AdditionalInfo>,
2022}
2023
2024#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2025pub struct RegulatoryInformationISHAISHAregulationCompositionConcentration {
2026 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
2027 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
2028}
2029
2030#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2031pub struct RegulatoryInformationOtherLegislation {
2032 #[serde(rename = "Legislation", skip_serializing_if = "Option::is_none")]
2033 pub legislation: Option<Vec<RegulatoryInformationOtherLegislationLegislation>>,
2034 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2035 pub additional_info: Option<AdditionalInfo>,
2036}
2037
2038#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2039pub struct RegulatoryInformationOtherLegislationLegislation {
2040 #[serde(rename = "LegislationName", skip_serializing_if = "Option::is_none")]
2041 pub legislation_name: Option<String>,
2042 #[serde(rename = "Regulations", skip_serializing_if = "Option::is_none")]
2043 pub regulations: Option<Vec<RegulatoryInformationOtherLegislationLegislationRegulations>>,
2044}
2045
2046#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2047pub struct RegulatoryInformationOtherLegislationLegislationRegulations {
2048 #[serde(rename = "RegulationName", skip_serializing_if = "Option::is_none")]
2049 pub regulation_name: Option<String>,
2050 #[serde(rename = "Composition", skip_serializing_if = "Option::is_none")]
2051 pub composition: Option<Vec<RegulatoryInformationOtherLegislationLegislationRegulationsComposition>>,
2052 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2053 pub additional_info: Option<AdditionalInfo>,
2054}
2055
2056#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2057pub struct RegulatoryInformationOtherLegislationLegislationRegulationsComposition {
2058 #[serde(rename = "SubstanceIdentifiers", skip_serializing_if = "Option::is_none")]
2059 pub substance_identifiers: Option<SubstanceIdentifiers>,
2060 #[serde(rename = "Classification", skip_serializing_if = "Option::is_none")]
2061 pub classification: Option<String>,
2062 #[serde(rename = "isApplicable", skip_serializing_if = "Option::is_none")]
2063 pub is_applicable: Option<bool>,
2064 #[serde(rename = "ImplementationDate", skip_serializing_if = "Option::is_none")]
2065 pub implementation_date: Option<String>,
2066 #[serde(rename = "Concentration", skip_serializing_if = "Option::is_none")]
2067 pub concentration: Option<RegulatoryInformationOtherLegislationLegislationRegulationsCompositionConcentration>,
2068 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2069 pub additional_info: Option<AdditionalInfo>,
2070}
2071
2072#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2073pub struct RegulatoryInformationOtherLegislationLegislationRegulationsCompositionConcentration {
2074 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
2075 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
2076}
2077
2078#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2079pub struct RegulatoryInformationPDSCA {
2080 #[serde(rename = "Composition", skip_serializing_if = "Option::is_none")]
2081 pub composition: Option<Vec<RegulatoryInformationPDSCAComposition>>,
2082 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2083 pub additional_info: Option<AdditionalInfo>,
2084}
2085
2086#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2087pub struct RegulatoryInformationPDSCAComposition {
2088 #[serde(rename = "SubstanceIdentifiers", skip_serializing_if = "Option::is_none")]
2089 pub substance_identifiers: Option<SubstanceIdentifiers>,
2090 #[serde(rename = "RegulationName", skip_serializing_if = "Option::is_none")]
2091 pub regulation_name: Option<String>,
2092 #[serde(rename = "Classification", skip_serializing_if = "Option::is_none")]
2093 pub classification: Option<String>,
2094 #[serde(rename = "isApplicable", skip_serializing_if = "Option::is_none")]
2095 pub is_applicable: Option<bool>,
2096 #[serde(rename = "ImplementationDate", skip_serializing_if = "Option::is_none")]
2097 pub implementation_date: Option<String>,
2098 #[serde(rename = "Concentration", skip_serializing_if = "Option::is_none")]
2099 pub concentration: Option<RegulatoryInformationPDSCACompositionConcentration>,
2100 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2101 pub additional_info: Option<AdditionalInfo>,
2102}
2103
2104#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2105pub struct RegulatoryInformationPDSCACompositionConcentration {
2106 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
2107 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
2108}
2109
2110#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2111pub struct RegulatoryInformationPRTRLaw {
2112 #[serde(rename = "Composition", skip_serializing_if = "Option::is_none")]
2113 pub composition: Option<Vec<RegulatoryInformationPRTRLawComposition>>,
2114 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2115 pub additional_info: Option<AdditionalInfo>,
2116}
2117
2118#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2119pub struct RegulatoryInformationPRTRLawComposition {
2120 #[serde(rename = "SubstanceIdentifiers", skip_serializing_if = "Option::is_none")]
2121 pub substance_identifiers: Option<SubstanceIdentifiers>,
2122 #[serde(rename = "Classification", skip_serializing_if = "Option::is_none")]
2123 pub classification: Option<String>,
2124 #[serde(rename = "JPSNo", skip_serializing_if = "Option::is_none")]
2125 pub jps_no: Option<String>,
2126 #[serde(rename = "isApplicable", skip_serializing_if = "Option::is_none")]
2127 pub is_applicable: Option<bool>,
2128 #[serde(rename = "ImplementationDate", skip_serializing_if = "Option::is_none")]
2129 pub implementation_date: Option<String>,
2130 #[serde(rename = "Concentration", skip_serializing_if = "Option::is_none")]
2131 pub concentration: Option<RegulatoryInformationPRTRLawCompositionConcentration>,
2132 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2133 pub additional_info: Option<AdditionalInfo>,
2134}
2135
2136#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2137pub struct RegulatoryInformationPRTRLawCompositionConcentration {
2138 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
2139 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
2140}
2141
2142#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2143pub struct StabilityReactivity {
2144 #[serde(rename = "ReactivityDescription", skip_serializing_if = "Option::is_none")]
2145 pub reactivity_description: Option<String>,
2146 #[serde(rename = "StabilityDescription", skip_serializing_if = "Option::is_none")]
2147 pub stability_description: Option<String>,
2148 #[serde(rename = "HazardousReactions", skip_serializing_if = "Option::is_none")]
2149 pub hazardous_reactions: Option<StabilityReactivityHazardousReactions>,
2150 #[serde(rename = "ConditionsToAvoid", skip_serializing_if = "Option::is_none")]
2151 pub conditions_to_avoid: Option<String>,
2152 #[serde(rename = "MaterialsToAvoid", skip_serializing_if = "Option::is_none")]
2153 pub materials_to_avoid: Option<String>,
2154 #[serde(rename = "HazardousDecompositionProducts", skip_serializing_if = "Option::is_none")]
2155 pub hazardous_decomposition_products: Option<StabilityReactivityHazardousDecompositionProducts>,
2156 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2157 pub additional_info: Option<AdditionalInfo>,
2158}
2159
2160#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2161pub struct StabilityReactivityHazardousDecompositionProducts {
2162 #[serde(rename = "Substance", skip_serializing_if = "Option::is_none",
2163 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
2164 pub substance: Option<String>,
2165 #[serde(rename = "Condition", skip_serializing_if = "Option::is_none",
2166 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
2167 pub condition: Option<String>,
2168 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2169 pub additional_info: Option<AdditionalInfo>,
2170}
2171
2172#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2173pub struct StabilityReactivityHazardousReactions {
2174 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
2175 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
2176 pub full_text: Option<String>,
2177 #[serde(rename = "Flammability", skip_serializing_if = "Option::is_none")]
2178 pub flammability: Option<String>,
2179 #[serde(rename = "IgnitionCharacteristics", skip_serializing_if = "Option::is_none")]
2180 pub ignition_characteristics: Option<String>,
2181 #[serde(rename = "OxidizingProperties", skip_serializing_if = "Option::is_none")]
2182 pub oxidizing_properties: Option<String>,
2183 #[serde(rename = "SelfReactivityAndExplosiveness", skip_serializing_if = "Option::is_none")]
2184 pub self_reactivity_and_explosiveness: Option<String>,
2185 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2186 pub additional_info: Option<AdditionalInfo>,
2187}
2188
2189#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2190pub struct ToxicologicalInformation {
2191 #[serde(rename = "CompositionType", skip_serializing_if = "Option::is_none")]
2192 pub composition_type: Option<String>,
2193 #[serde(rename = "SubstanceIdentifiers", skip_serializing_if = "Option::is_none")]
2194 pub substance_identifiers: Option<SubstanceIdentifiers>,
2195 #[serde(rename = "AcuteToxicity", skip_serializing_if = "Option::is_none")]
2196 pub acute_toxicity: Option<ToxicologicalInformationAcuteToxicity>,
2197 #[serde(rename = "SkinCorrosionIrritation", skip_serializing_if = "Option::is_none")]
2198 pub skin_corrosion_irritation: Option<ToxicologicalInformationSkinCorrosionIrritation>,
2199 #[serde(rename = "EyeDamageOrIrritation", skip_serializing_if = "Option::is_none")]
2200 pub eye_damage_or_irritation: Option<ToxicologicalInformationEyeDamageOrIrritation>,
2201 #[serde(rename = "RespiratorySensitisation", skip_serializing_if = "Option::is_none")]
2202 pub respiratory_sensitisation: Option<ToxicologicalInformationRespiratorySensitisation>,
2203 #[serde(rename = "SkinSensitisation", skip_serializing_if = "Option::is_none")]
2204 pub skin_sensitisation: Option<ToxicologicalInformationSkinSensitisation>,
2205 #[serde(rename = "GermCellMutagenicity", skip_serializing_if = "Option::is_none")]
2206 pub germ_cell_mutagenicity: Option<ToxicologicalInformationGermCellMutagenicity>,
2207 #[serde(rename = "Carcinogenicity", skip_serializing_if = "Option::is_none")]
2208 pub carcinogenicity: Option<ToxicologicalInformationCarcinogenicity>,
2209 #[serde(rename = "ReproductiveToxicity", skip_serializing_if = "Option::is_none")]
2210 pub reproductive_toxicity: Option<ToxicologicalInformationReproductiveToxicity>,
2211 #[serde(rename = "SpecificTargetOrganSE", skip_serializing_if = "Option::is_none")]
2212 pub specific_target_organ_se: Option<ToxicologicalInformationSpecificTargetOrganSE>,
2213 #[serde(rename = "SpecificTargetOrganRE", skip_serializing_if = "Option::is_none")]
2214 pub specific_target_organ_re: Option<ToxicologicalInformationSpecificTargetOrganRE>,
2215 #[serde(rename = "AspirationHazard", skip_serializing_if = "Option::is_none")]
2216 pub aspiration_hazard: Option<ToxicologicalInformationAspirationHazard>,
2217 #[serde(rename = "AdditionalToxicologicalInformation", skip_serializing_if = "Option::is_none")]
2218 pub additional_toxicological_information: Option<String>,
2219}
2220
2221#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2222pub struct ToxicologicalInformationAcuteToxicity {
2223 #[serde(rename = "ExposureRoute", skip_serializing_if = "Option::is_none")]
2224 pub exposure_route: Option<Vec<ToxicologicalInformationAcuteToxicityExposureRoute>>,
2225 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2226 pub additional_info: Option<AdditionalInfo>,
2227}
2228
2229#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2230pub struct ToxicologicalInformationAcuteToxicityExposureRoute {
2231 #[serde(rename = "ExposureRouteName", skip_serializing_if = "Option::is_none")]
2232 pub exposure_route_name: Option<String>,
2233 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
2234 pub category: Option<String>,
2235 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
2236 pub rationale: Option<String>,
2237 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
2238 pub result: Option<Vec<ToxicologicalInformationAcuteToxicityExposureRouteResult>>,
2239 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2240 pub additional_info: Option<AdditionalInfo>,
2241}
2242
2243#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2244pub struct ToxicologicalInformationAcuteToxicityExposureRouteResult {
2245 #[serde(rename = "toxicityTestInfo", skip_serializing_if = "Option::is_none")]
2246 pub toxicity_test_info: Option<ToxicityTestInfo>,
2247 #[serde(rename = "Ate", skip_serializing_if = "Option::is_none")]
2248 pub ate: Option<Vec<ToxicologicalInformationAcuteToxicityExposureRouteResultAte>>,
2249 #[serde(rename = "HumanExperience", skip_serializing_if = "Option::is_none")]
2250 pub human_experience: Option<Vec<String>>,
2251 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2252 pub additional_info: Option<AdditionalInfo>,
2253}
2254
2255#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2256pub struct ToxicologicalInformationAcuteToxicityExposureRouteResultAte {
2257 #[serde(rename = "AteTypes", skip_serializing_if = "Option::is_none")]
2258 pub ate_types: Option<String>,
2259 #[serde(rename = "NumericRangeWithUnitAndQualifier", skip_serializing_if = "Option::is_none")]
2260 pub numeric_range_with_unit_and_qualifier: Option<NumericRangeWithUnitAndQualifier>,
2261}
2262
2263#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2264pub struct ToxicologicalInformationAspirationHazard {
2265 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
2266 pub category: Option<String>,
2267 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
2268 pub rationale: Option<String>,
2269 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
2270 pub result: Option<Vec<ToxicologicalInformationAspirationHazardResult>>,
2271 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2272 pub additional_info: Option<AdditionalInfo>,
2273}
2274
2275#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2276pub struct ToxicologicalInformationAspirationHazardResult {
2277 #[serde(rename = "HumanExperience", skip_serializing_if = "Option::is_none")]
2278 pub human_experience: Option<Vec<String>>,
2279 #[serde(rename = "DynamicViscosity", skip_serializing_if = "Option::is_none")]
2280 pub dynamic_viscosity: Option<f64>,
2281 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
2282 pub unit: Option<String>,
2283 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2284 pub additional_info: Option<AdditionalInfo>,
2285}
2286
2287#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2288pub struct ToxicologicalInformationCarcinogenicity {
2289 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
2290 pub category: Option<String>,
2291 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
2292 pub rationale: Option<String>,
2293 #[serde(rename = "EvaluationOrganization", skip_serializing_if = "Option::is_none")]
2294 pub evaluation_organization: Option<Vec<ToxicologicalInformationCarcinogenicityEvaluationOrganization>>,
2295 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
2296 pub result: Option<Vec<ToxicologicalInformationCarcinogenicityResult>>,
2297 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2298 pub additional_info: Option<AdditionalInfo>,
2299}
2300
2301#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2302pub struct ToxicologicalInformationCarcinogenicityEvaluationOrganization {
2303 #[serde(rename = "OrganizationName", skip_serializing_if = "Option::is_none")]
2304 pub organization_name: Option<String>,
2305 #[serde(rename = "EvaluationResults", skip_serializing_if = "Option::is_none")]
2306 pub evaluation_results: Option<String>,
2307 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2308 pub additional_info: Option<AdditionalInfo>,
2309 #[serde(rename = "ExplanatoryNotes", skip_serializing_if = "Option::is_none")]
2310 pub explanatory_notes: Option<String>,
2311}
2312
2313#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2314pub struct ToxicologicalInformationCarcinogenicityResult {
2315 #[serde(rename = "toxicityTestInfo", skip_serializing_if = "Option::is_none")]
2316 pub toxicity_test_info: Option<ToxicityTestInfo>,
2317 #[serde(rename = "HumanExperience", skip_serializing_if = "Option::is_none")]
2318 pub human_experience: Option<Vec<String>>,
2319 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2320 pub additional_info: Option<AdditionalInfo>,
2321}
2322
2323#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2324pub struct ToxicologicalInformationEyeDamageOrIrritation {
2325 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
2326 pub category: Option<String>,
2327 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
2328 pub rationale: Option<String>,
2329 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
2330 pub result: Option<Vec<ToxicologicalInformationEyeDamageOrIrritationResult>>,
2331 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2332 pub additional_info: Option<AdditionalInfo>,
2333}
2334
2335#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2336pub struct ToxicologicalInformationEyeDamageOrIrritationResult {
2337 #[serde(rename = "toxicityTestInfo", skip_serializing_if = "Option::is_none")]
2338 pub toxicity_test_info: Option<ToxicityTestInfo>,
2339 #[serde(rename = "HumanExperience", skip_serializing_if = "Option::is_none")]
2340 pub human_experience: Option<Vec<String>>,
2341 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2342 pub additional_info: Option<AdditionalInfo>,
2343}
2344
2345#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2346pub struct ToxicologicalInformationGermCellMutagenicity {
2347 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
2348 pub category: Option<String>,
2349 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
2350 pub rationale: Option<String>,
2351 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
2352 pub result: Option<Vec<ToxicologicalInformationGermCellMutagenicityResult>>,
2353 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2354 pub additional_info: Option<AdditionalInfo>,
2355}
2356
2357#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2358pub struct ToxicologicalInformationGermCellMutagenicityResult {
2359 #[serde(rename = "Species", skip_serializing_if = "Option::is_none")]
2360 pub species: Option<String>,
2361 #[serde(rename = "toxicityTestInfo", skip_serializing_if = "Option::is_none")]
2362 pub toxicity_test_info: Option<ToxicityTestInfo>,
2363 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2364 pub additional_info: Option<AdditionalInfo>,
2365}
2366
2367#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2368pub struct ToxicologicalInformationReproductiveToxicity {
2369 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
2370 pub category: Option<String>,
2371 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
2372 pub rationale: Option<String>,
2373 #[serde(rename = "ReproductiveEffects", skip_serializing_if = "Option::is_none")]
2374 pub reproductive_effects: Option<String>,
2375 #[serde(rename = "DevelopmentalEffects", skip_serializing_if = "Option::is_none")]
2376 pub developmental_effects: Option<String>,
2377 #[serde(rename = "Lactation", skip_serializing_if = "Option::is_none")]
2378 pub lactation: Option<String>,
2379 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
2380 pub result: Option<Vec<ToxicologicalInformationReproductiveToxicityResult>>,
2381 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2382 pub additional_info: Option<AdditionalInfo>,
2383}
2384
2385#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2386pub struct ToxicologicalInformationReproductiveToxicityResult {
2387 #[serde(rename = "toxicityTestInfo", skip_serializing_if = "Option::is_none")]
2388 pub toxicity_test_info: Option<ToxicityTestInfo>,
2389 #[serde(rename = "HumanExperience", skip_serializing_if = "Option::is_none")]
2390 pub human_experience: Option<Vec<String>>,
2391 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2392 pub additional_info: Option<AdditionalInfo>,
2393}
2394
2395#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2396pub struct ToxicologicalInformationRespiratorySensitisation {
2397 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
2398 pub category: Option<String>,
2399 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
2400 pub rationale: Option<String>,
2401 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
2402 pub result: Option<Vec<ToxicologicalInformationRespiratorySensitisationResult>>,
2403 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2404 pub additional_info: Option<AdditionalInfo>,
2405}
2406
2407#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2408pub struct ToxicologicalInformationRespiratorySensitisationResult {
2409 #[serde(rename = "toxicityTestInfo", skip_serializing_if = "Option::is_none")]
2410 pub toxicity_test_info: Option<ToxicityTestInfo>,
2411 #[serde(rename = "HumanExperience", skip_serializing_if = "Option::is_none")]
2412 pub human_experience: Option<Vec<String>>,
2413 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2414 pub additional_info: Option<AdditionalInfo>,
2415}
2416
2417#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2418pub struct ToxicologicalInformationSkinCorrosionIrritation {
2419 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
2420 pub category: Option<String>,
2421 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
2422 pub rationale: Option<String>,
2423 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
2424 pub result: Option<Vec<ToxicologicalInformationSkinCorrosionIrritationResult>>,
2425 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2426 pub additional_info: Option<AdditionalInfo>,
2427}
2428
2429#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2430pub struct ToxicologicalInformationSkinCorrosionIrritationResult {
2431 #[serde(rename = "toxicityTestInfo", skip_serializing_if = "Option::is_none")]
2432 pub toxicity_test_info: Option<ToxicityTestInfo>,
2433 #[serde(rename = "HumanExperience", skip_serializing_if = "Option::is_none")]
2434 pub human_experience: Option<Vec<String>>,
2435 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2436 pub additional_info: Option<AdditionalInfo>,
2437}
2438
2439#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2440pub struct ToxicologicalInformationSkinSensitisation {
2441 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
2442 pub category: Option<String>,
2443 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
2444 pub rationale: Option<String>,
2445 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
2446 pub result: Option<Vec<ToxicologicalInformationSkinSensitisationResult>>,
2447 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2448 pub additional_info: Option<AdditionalInfo>,
2449}
2450
2451#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2452pub struct ToxicologicalInformationSkinSensitisationResult {
2453 #[serde(rename = "toxicityTestInfo", skip_serializing_if = "Option::is_none")]
2454 pub toxicity_test_info: Option<ToxicityTestInfo>,
2455 #[serde(rename = "HumanExperience", skip_serializing_if = "Option::is_none")]
2456 pub human_experience: Option<Vec<String>>,
2457 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2458 pub additional_info: Option<AdditionalInfo>,
2459}
2460
2461#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2462pub struct ToxicologicalInformationSpecificTargetOrganRE {
2463 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
2464 pub category: Option<String>,
2465 #[serde(rename = "TargetOrgan", skip_serializing_if = "Option::is_none")]
2466 pub target_organ: Option<Vec<String>>,
2467 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
2468 pub rationale: Option<String>,
2469 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
2470 pub result: Option<Vec<ToxicologicalInformationSpecificTargetOrganREResult>>,
2471 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2472 pub additional_info: Option<AdditionalInfo>,
2473}
2474
2475#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2476pub struct ToxicologicalInformationSpecificTargetOrganREResult {
2477 #[serde(rename = "toxicityTestInfo", skip_serializing_if = "Option::is_none")]
2478 pub toxicity_test_info: Option<ToxicityTestInfo>,
2479 #[serde(rename = "STOTData", skip_serializing_if = "Option::is_none")]
2480 pub stot_data: Option<Vec<ToxicologicalInformationSpecificTargetOrganREResultSTOTData>>,
2481 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2482 pub additional_info: Option<AdditionalInfo>,
2483}
2484
2485#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2486pub struct ToxicologicalInformationSpecificTargetOrganREResultSTOTData {
2487 #[serde(rename = "Dose/Concentration", skip_serializing_if = "Option::is_none")]
2488 pub dose_concentration: Option<f64>,
2489 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
2490 pub unit: Option<String>,
2491 #[serde(rename = "OrganAffected", skip_serializing_if = "Option::is_none")]
2492 pub organ_affected: Option<String>,
2493 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
2494 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
2495 pub full_text: Option<String>,
2496 #[serde(rename = "ResultEvaluation", skip_serializing_if = "Option::is_none")]
2497 pub result_evaluation: Option<String>,
2498}
2499
2500#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2501pub struct ToxicologicalInformationSpecificTargetOrganSE {
2502 #[serde(rename = "Category", skip_serializing_if = "Option::is_none")]
2503 pub category: Option<String>,
2504 #[serde(rename = "TargetOrgan", skip_serializing_if = "Option::is_none")]
2505 pub target_organ: Option<Vec<String>>,
2506 #[serde(rename = "Rationale", skip_serializing_if = "Option::is_none")]
2507 pub rationale: Option<String>,
2508 #[serde(rename = "Result", skip_serializing_if = "Option::is_none")]
2509 pub result: Option<Vec<ToxicologicalInformationSpecificTargetOrganSEResult>>,
2510 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2511 pub additional_info: Option<AdditionalInfo>,
2512}
2513
2514#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2515pub struct ToxicologicalInformationSpecificTargetOrganSEResult {
2516 #[serde(rename = "toxicityTestInfo", skip_serializing_if = "Option::is_none")]
2517 pub toxicity_test_info: Option<ToxicityTestInfo>,
2518 #[serde(rename = "STOTData", skip_serializing_if = "Option::is_none")]
2519 pub stot_data: Option<Vec<ToxicologicalInformationSpecificTargetOrganSEResultSTOTData>>,
2520 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2521 pub additional_info: Option<AdditionalInfo>,
2522}
2523
2524#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2525pub struct ToxicologicalInformationSpecificTargetOrganSEResultSTOTData {
2526 #[serde(rename = "Dose/Concentration", skip_serializing_if = "Option::is_none")]
2527 pub dose_concentration: Option<f64>,
2528 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
2529 pub unit: Option<String>,
2530 #[serde(rename = "OrganAffected", skip_serializing_if = "Option::is_none")]
2531 pub organ_affected: Option<String>,
2532 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
2533 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
2534 pub full_text: Option<String>,
2535 #[serde(rename = "ResultEvaluation", skip_serializing_if = "Option::is_none")]
2536 pub result_evaluation: Option<String>,
2537}
2538
2539#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2540pub struct TransportInformation {
2541 #[serde(rename = "InternationalRegulations", skip_serializing_if = "Option::is_none")]
2542 pub international_regulations: Option<Vec<TransportInformationInternationalRegulations>>,
2543 #[serde(rename = "DomesticRegulations", skip_serializing_if = "Option::is_none")]
2544 pub domestic_regulations: Option<Vec<TransportInformationDomesticRegulations>>,
2545 #[serde(rename = "SpecialPrecautionUser", skip_serializing_if = "Option::is_none")]
2546 pub special_precaution_user: Option<Vec<TransportInformationSpecialPrecautionUser>>,
2547 #[serde(rename = "SpecialProvisions", skip_serializing_if = "Option::is_none")]
2548 pub special_provisions: Option<Vec<TransportInformationSpecialProvisions>>,
2549 #[serde(rename = "AccidentalReleaseMeasures", skip_serializing_if = "Option::is_none")]
2550 pub accidental_release_measures: Option<String>,
2551 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2552 pub additional_info: Option<AdditionalInfo>,
2553}
2554
2555#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2556pub struct TransportInformationDomesticRegulations {
2557 #[serde(rename = "TransportationType", skip_serializing_if = "Option::is_none")]
2558 pub transportation_type: Option<String>,
2559 #[serde(rename = "LegislationName", skip_serializing_if = "Option::is_none")]
2560 pub legislation_name: Option<String>,
2561 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
2562 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
2563 pub full_text: Option<String>,
2564 #[serde(rename = "Erg", skip_serializing_if = "Option::is_none")]
2565 pub erg: Option<String>,
2566 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2567 pub additional_info: Option<AdditionalInfo>,
2568}
2569
2570#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2571pub struct TransportInformationInternationalRegulations {
2572 #[serde(rename = "RegulationName", skip_serializing_if = "Option::is_none")]
2573 pub regulation_name: Option<Vec<TransportInformationInternationalRegulationsRegulationName>>,
2574 #[serde(rename = "MarinePollutant", skip_serializing_if = "Option::is_none")]
2575 pub marine_pollutant: Option<String>,
2576 #[serde(rename = "TransportInBulkSubstanceName", skip_serializing_if = "Option::is_none")]
2577 pub transport_in_bulk_substance_name: Option<String>,
2578 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2579 pub additional_info: Option<AdditionalInfo>,
2580}
2581
2582#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2583pub struct TransportInformationInternationalRegulationsRegulationName {
2584 #[serde(rename = "TransportationType", skip_serializing_if = "Option::is_none")]
2585 pub transportation_type: Option<String>,
2586 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
2587 default, deserialize_with = "crate::schema::serde_flex::flex_string_opt")]
2588 pub full_text: Option<String>,
2589 #[serde(rename = "UnNo", skip_serializing_if = "Option::is_none")]
2590 pub un_no: Option<String>,
2591 #[serde(rename = "ProperShippingName", skip_serializing_if = "Option::is_none")]
2592 pub proper_shipping_name: Option<String>,
2593 #[serde(rename = "DangerReleasingSubstance", skip_serializing_if = "Option::is_none")]
2594 pub danger_releasing_substance: Option<String>,
2595 #[serde(rename = "PackingGroup", skip_serializing_if = "Option::is_none")]
2596 pub packing_group: Option<String>,
2597 #[serde(rename = "SubsidiaryRisk", skip_serializing_if = "Option::is_none")]
2598 pub subsidiary_risk: Option<String>,
2599 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2600 pub additional_info: Option<AdditionalInfo>,
2601}
2602
2603#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2604pub struct TransportInformationSpecialPrecautionUser {
2605 #[serde(rename = "TransportationType", skip_serializing_if = "Option::is_none")]
2606 pub transportation_type: Option<String>,
2607 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
2608 default, deserialize_with = "crate::schema::serde_flex::flex_vec_string_opt")]
2609 pub full_text: Option<Vec<String>>,
2610 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2611 pub additional_info: Option<AdditionalInfo>,
2612}
2613
2614#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2615pub struct TransportInformationSpecialProvisions {
2616 #[serde(rename = "TransportationType", skip_serializing_if = "Option::is_none")]
2617 pub transportation_type: Option<String>,
2618 #[serde(rename = "FullText", skip_serializing_if = "Option::is_none",
2619 default, deserialize_with = "crate::schema::serde_flex::flex_vec_string_opt")]
2620 pub full_text: Option<Vec<String>>,
2621 #[serde(rename = "AdditionalInfo", skip_serializing_if = "Option::is_none")]
2622 pub additional_info: Option<AdditionalInfo>,
2623}
2624
2625#[derive(Debug, Clone, Serialize, Deserialize, Default)]
2626pub struct SdsRoot {
2627 #[serde(rename = "Datasheet", skip_serializing_if = "Option::is_none")]
2628 pub datasheet: Option<Datasheet>,
2629 #[serde(rename = "Identification", skip_serializing_if = "Option::is_none")]
2630 pub identification: Option<Identification>,
2631 #[serde(rename = "HazardIdentification", skip_serializing_if = "Option::is_none")]
2632 pub hazard_identification: Option<HazardIdentification>,
2633 #[serde(rename = "Composition", skip_serializing_if = "Option::is_none")]
2634 pub composition: Option<Composition>,
2635 #[serde(rename = "FirstAidMeasures", skip_serializing_if = "Option::is_none")]
2636 pub first_aid_measures: Option<FirstAidMeasures>,
2637 #[serde(rename = "FireFightingMeasures", skip_serializing_if = "Option::is_none")]
2638 pub fire_fighting_measures: Option<FireFightingMeasures>,
2639 #[serde(rename = "AccidentalReleaseMeasures", skip_serializing_if = "Option::is_none")]
2640 pub accidental_release_measures: Option<AccidentalReleaseMeasures>,
2641 #[serde(rename = "HandlingAndStorage", skip_serializing_if = "Option::is_none")]
2642 pub handling_and_storage: Option<HandlingAndStorage>,
2643 #[serde(rename = "ExposureControlPersonalProtection", skip_serializing_if = "Option::is_none")]
2644 pub exposure_control_personal_protection: Option<ExposureControlPersonalProtection>,
2645 #[serde(rename = "PhysicalChemicalProperties", skip_serializing_if = "Option::is_none")]
2646 pub physical_chemical_properties: Option<PhysicalChemicalProperties>,
2647 #[serde(rename = "StabilityReactivity", skip_serializing_if = "Option::is_none")]
2648 pub stability_reactivity: Option<StabilityReactivity>,
2649 #[serde(rename = "ToxicologicalInformation", skip_serializing_if = "Option::is_none")]
2650 pub toxicological_information: Option<Vec<ToxicologicalInformation>>,
2651 #[serde(rename = "EcologicalInformation", skip_serializing_if = "Option::is_none")]
2652 pub ecological_information: Option<Vec<EcologicalInformation>>,
2653 #[serde(rename = "DisposalConsiderations", skip_serializing_if = "Option::is_none")]
2654 pub disposal_considerations: Option<DisposalConsiderations>,
2655 #[serde(rename = "TransportInformation", skip_serializing_if = "Option::is_none")]
2656 pub transport_information: Option<TransportInformation>,
2657 #[serde(rename = "RegulatoryInformation", skip_serializing_if = "Option::is_none")]
2658 pub regulatory_information: Option<RegulatoryInformation>,
2659 #[serde(rename = "OtherInformation", skip_serializing_if = "Option::is_none")]
2660 pub other_information: Option<OtherInformation>,
2661}