ftm_types/generated/
entities.rs

1#![allow(missing_docs)]
2#[cfg(feature = "builder")]
3use bon::Builder;
4use serde::{Deserialize, Serialize};
5/// Deserialize a `Vec<f64>` whose elements may arrive as JSON strings
6/// (e.g. `["6000.00"]`) or as JSON numbers (e.g. `[6000.0]`).
7fn deserialize_f64_vec<'de, D>(deserializer: D) -> Result<Vec<f64>, D::Error>
8where
9    D: serde::Deserializer<'de>,
10{
11    Vec::<serde_json::Value>::deserialize(deserializer)?
12        .into_iter()
13        .map(|v| match v {
14            serde_json::Value::Number(n) => n
15                .as_f64()
16                .ok_or_else(|| serde::de::Error::custom("number out of f64 range")),
17            serde_json::Value::String(s) => s.parse::<f64>().map_err(serde::de::Error::custom),
18            other => Err(serde::de::Error::custom(format!(
19                "expected number or numeric string, got {other}"
20            ))),
21        })
22        .collect()
23}
24/// Same as [`deserialize_f64_vec`] but wrapped in `Some`.
25/// Used for optional number fields so the field can still be absent (`None`)
26/// while a present value tolerates string-encoded numbers.
27fn deserialize_opt_f64_vec<'de, D>(deserializer: D) -> Result<Option<Vec<f64>>, D::Error>
28where
29    D: serde::Deserializer<'de>,
30{
31    deserialize_f64_vec(deserializer).map(Some)
32}
33///FTM Schema: Address
34#[derive(Debug, Clone, Serialize, Deserialize)]
35#[cfg_attr(feature = "builder", derive(Builder))]
36#[serde(rename_all = "camelCase")]
37pub struct Address {
38    pub id: String,
39    #[cfg_attr(feature = "builder", builder(default = "Address".to_string()))]
40    pub schema: String,
41    ///Property: Address
42    #[serde(skip_serializing_if = "Option::is_none")]
43    pub address: Option<Vec<String>>,
44    ///Property: Address
45    #[serde(skip_serializing_if = "Option::is_none")]
46    pub address_entity: Option<Vec<String>>,
47    ///Property: Aleph URL
48    #[serde(skip_serializing_if = "Option::is_none")]
49    pub aleph_url: Option<Vec<String>>,
50    ///Property: Alias
51    #[serde(skip_serializing_if = "Option::is_none")]
52    pub alias: Option<Vec<String>>,
53    ///Property: City
54    #[serde(skip_serializing_if = "Option::is_none")]
55    pub city: Option<Vec<String>>,
56    ///Property: Country
57    #[serde(skip_serializing_if = "Option::is_none")]
58    pub country: Option<Vec<String>>,
59    ///Property: Created at
60    #[serde(skip_serializing_if = "Option::is_none")]
61    pub created_at: Option<Vec<String>>,
62    ///Property: Description
63    #[serde(skip_serializing_if = "Option::is_none")]
64    pub description: Option<Vec<String>>,
65    ///Property: Full address
66    #[serde(skip_serializing_if = "Option::is_none")]
67    pub full: Option<Vec<String>>,
68    ///Property: Google Places ID
69    #[serde(skip_serializing_if = "Option::is_none")]
70    pub google_place_id: Option<Vec<String>>,
71    ///Property: Index text
72    #[serde(skip_serializing_if = "Option::is_none")]
73    pub index_text: Option<Vec<String>>,
74    ///Property: Keywords
75    #[serde(skip_serializing_if = "Option::is_none")]
76    pub keywords: Option<Vec<String>>,
77    ///Property: Latitude
78    #[serde(
79        skip_serializing_if = "Option::is_none",
80        deserialize_with = "deserialize_opt_f64_vec",
81        default
82    )]
83    pub latitude: Option<Vec<f64>>,
84    ///Property: Longitude
85    #[serde(
86        skip_serializing_if = "Option::is_none",
87        deserialize_with = "deserialize_opt_f64_vec",
88        default
89    )]
90    pub longitude: Option<Vec<f64>>,
91    ///Property: Modified on
92    #[serde(skip_serializing_if = "Option::is_none")]
93    pub modified_at: Option<Vec<String>>,
94    ///Property: Name
95    #[serde(default)]
96    pub name: Vec<String>,
97    ///Property: Notes
98    #[serde(skip_serializing_if = "Option::is_none")]
99    pub notes: Option<Vec<String>>,
100    ///Property: OpenStreetmap Place ID
101    #[serde(skip_serializing_if = "Option::is_none")]
102    pub osm_id: Option<Vec<String>>,
103    ///Property: PO Box
104    #[serde(skip_serializing_if = "Option::is_none")]
105    pub post_office_box: Option<Vec<String>>,
106    ///Property: Postal code
107    #[serde(skip_serializing_if = "Option::is_none")]
108    pub postal_code: Option<Vec<String>>,
109    ///Property: Previous name
110    #[serde(skip_serializing_if = "Option::is_none")]
111    pub previous_name: Option<Vec<String>>,
112    ///Property: Program
113    #[serde(skip_serializing_if = "Option::is_none")]
114    pub program: Option<Vec<String>>,
115    ///Property: Program ID
116    #[serde(skip_serializing_if = "Option::is_none")]
117    pub program_id: Option<Vec<String>>,
118    ///Property: Source document
119    #[serde(skip_serializing_if = "Option::is_none")]
120    pub proof: Option<Vec<String>>,
121    ///Property: Publishing source
122    #[serde(skip_serializing_if = "Option::is_none")]
123    pub publisher: Option<Vec<String>>,
124    ///Property: Publishing source URL
125    #[serde(skip_serializing_if = "Option::is_none")]
126    pub publisher_url: Option<Vec<String>>,
127    ///Property: Region
128    #[serde(skip_serializing_if = "Option::is_none")]
129    pub region: Option<Vec<String>>,
130    ///Property: Remarks
131    #[serde(skip_serializing_if = "Option::is_none")]
132    pub remarks: Option<Vec<String>>,
133    ///Property: Retrieved on
134    #[serde(skip_serializing_if = "Option::is_none")]
135    pub retrieved_at: Option<Vec<String>>,
136    ///Property: Source link
137    #[serde(skip_serializing_if = "Option::is_none")]
138    pub source_url: Option<Vec<String>>,
139    ///Property: State
140    #[serde(skip_serializing_if = "Option::is_none")]
141    pub state: Option<Vec<String>>,
142    ///Property: Street address
143    #[serde(skip_serializing_if = "Option::is_none")]
144    pub street: Option<Vec<String>>,
145    ///Property: Street address (ctd.)
146    #[serde(skip_serializing_if = "Option::is_none")]
147    pub street2: Option<Vec<String>>,
148    ///Property: Summary
149    #[serde(skip_serializing_if = "Option::is_none")]
150    pub summary: Option<Vec<String>>,
151    ///Property: Topics
152    #[serde(skip_serializing_if = "Option::is_none")]
153    pub topics: Option<Vec<String>>,
154    ///Property: Weak alias
155    #[serde(skip_serializing_if = "Option::is_none")]
156    pub weak_alias: Option<Vec<String>>,
157    ///Property: Wikidata ID
158    #[serde(skip_serializing_if = "Option::is_none")]
159    pub wikidata_id: Option<Vec<String>>,
160    ///Property: Wikipedia Article
161    #[serde(skip_serializing_if = "Option::is_none")]
162    pub wikipedia_url: Option<Vec<String>>,
163}
164impl Address {
165    /// Create a new entity with the given ID
166    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
167    pub fn new(id: impl Into<String>) -> Self {
168        Self {
169            id: id.into(),
170            schema: "Address".to_string(),
171            address: None,
172            address_entity: None,
173            aleph_url: None,
174            alias: None,
175            city: None,
176            country: None,
177            created_at: None,
178            description: None,
179            full: None,
180            google_place_id: None,
181            index_text: None,
182            keywords: None,
183            latitude: None,
184            longitude: None,
185            modified_at: None,
186            name: Vec::new(),
187            notes: None,
188            osm_id: None,
189            post_office_box: None,
190            postal_code: None,
191            previous_name: None,
192            program: None,
193            program_id: None,
194            proof: None,
195            publisher: None,
196            publisher_url: None,
197            region: None,
198            remarks: None,
199            retrieved_at: None,
200            source_url: None,
201            state: None,
202            street: None,
203            street2: None,
204            summary: None,
205            topics: None,
206            weak_alias: None,
207            wikidata_id: None,
208            wikipedia_url: None,
209        }
210    }
211    /// Get the schema name
212    pub fn schema_name() -> &'static str {
213        "Address"
214    }
215}
216///FTM Schema: Airplane
217#[derive(Debug, Clone, Serialize, Deserialize)]
218#[cfg_attr(feature = "builder", derive(Builder))]
219#[serde(rename_all = "camelCase")]
220pub struct Airplane {
221    pub id: String,
222    #[cfg_attr(feature = "builder", builder(default = "Airplane".to_string()))]
223    pub schema: String,
224    ///Property: Address
225    #[serde(skip_serializing_if = "Option::is_none")]
226    pub address: Option<Vec<String>>,
227    ///Property: Address
228    #[serde(skip_serializing_if = "Option::is_none")]
229    pub address_entity: Option<Vec<String>>,
230    ///Property: Aleph URL
231    #[serde(skip_serializing_if = "Option::is_none")]
232    pub aleph_url: Option<Vec<String>>,
233    ///Property: Alias
234    #[serde(skip_serializing_if = "Option::is_none")]
235    pub alias: Option<Vec<String>>,
236    ///Property: Amount
237    #[serde(
238        skip_serializing_if = "Option::is_none",
239        deserialize_with = "deserialize_opt_f64_vec",
240        default
241    )]
242    pub amount: Option<Vec<f64>>,
243    ///Property: Amount in EUR
244    #[serde(
245        skip_serializing_if = "Option::is_none",
246        deserialize_with = "deserialize_opt_f64_vec",
247        default
248    )]
249    pub amount_eur: Option<Vec<f64>>,
250    ///Property: Amount in USD
251    #[serde(
252        skip_serializing_if = "Option::is_none",
253        deserialize_with = "deserialize_opt_f64_vec",
254        default
255    )]
256    pub amount_usd: Option<Vec<f64>>,
257    ///Property: Build Date
258    #[serde(skip_serializing_if = "Option::is_none")]
259    pub build_date: Option<Vec<String>>,
260    ///Property: Country
261    #[serde(skip_serializing_if = "Option::is_none")]
262    pub country: Option<Vec<String>>,
263    ///Property: Created at
264    #[serde(skip_serializing_if = "Option::is_none")]
265    pub created_at: Option<Vec<String>>,
266    ///Property: Currency
267    #[serde(skip_serializing_if = "Option::is_none")]
268    pub currency: Option<Vec<String>>,
269    ///Property: De-registration Date
270    #[serde(skip_serializing_if = "Option::is_none")]
271    pub deregistration_date: Option<Vec<String>>,
272    ///Property: Description
273    #[serde(skip_serializing_if = "Option::is_none")]
274    pub description: Option<Vec<String>>,
275    ///Property: ICAO aircraft type designator
276    #[serde(skip_serializing_if = "Option::is_none")]
277    pub icao_code: Option<Vec<String>>,
278    ///Property: Index text
279    #[serde(skip_serializing_if = "Option::is_none")]
280    pub index_text: Option<Vec<String>>,
281    ///Property: Keywords
282    #[serde(skip_serializing_if = "Option::is_none")]
283    pub keywords: Option<Vec<String>>,
284    ///Property: Manufacturer
285    #[serde(skip_serializing_if = "Option::is_none")]
286    pub manufacturer: Option<Vec<String>>,
287    ///Property: Model
288    #[serde(skip_serializing_if = "Option::is_none")]
289    pub model: Option<Vec<String>>,
290    ///Property: Modified on
291    #[serde(skip_serializing_if = "Option::is_none")]
292    pub modified_at: Option<Vec<String>>,
293    ///Property: Name
294    #[serde(default)]
295    pub name: Vec<String>,
296    ///Property: Notes
297    #[serde(skip_serializing_if = "Option::is_none")]
298    pub notes: Option<Vec<String>>,
299    ///Property: Operator
300    #[serde(skip_serializing_if = "Option::is_none")]
301    pub operator: Option<Vec<String>>,
302    ///Property: Owner
303    #[serde(skip_serializing_if = "Option::is_none")]
304    pub owner: Option<Vec<String>>,
305    ///Property: Previous name
306    #[serde(skip_serializing_if = "Option::is_none")]
307    pub previous_name: Option<Vec<String>>,
308    ///Property: Program
309    #[serde(skip_serializing_if = "Option::is_none")]
310    pub program: Option<Vec<String>>,
311    ///Property: Program ID
312    #[serde(skip_serializing_if = "Option::is_none")]
313    pub program_id: Option<Vec<String>>,
314    ///Property: Source document
315    #[serde(skip_serializing_if = "Option::is_none")]
316    pub proof: Option<Vec<String>>,
317    ///Property: Publishing source
318    #[serde(skip_serializing_if = "Option::is_none")]
319    pub publisher: Option<Vec<String>>,
320    ///Property: Publishing source URL
321    #[serde(skip_serializing_if = "Option::is_none")]
322    pub publisher_url: Option<Vec<String>>,
323    ///Property: Registration Date
324    #[serde(skip_serializing_if = "Option::is_none")]
325    pub registration_date: Option<Vec<String>>,
326    ///Property: Registration number
327    #[serde(skip_serializing_if = "Option::is_none")]
328    pub registration_number: Option<Vec<String>>,
329    ///Property: Retrieved on
330    #[serde(skip_serializing_if = "Option::is_none")]
331    pub retrieved_at: Option<Vec<String>>,
332    ///Property: Serial Number
333    #[serde(skip_serializing_if = "Option::is_none")]
334    pub serial_number: Option<Vec<String>>,
335    ///Property: Source link
336    #[serde(skip_serializing_if = "Option::is_none")]
337    pub source_url: Option<Vec<String>>,
338    ///Property: Summary
339    #[serde(skip_serializing_if = "Option::is_none")]
340    pub summary: Option<Vec<String>>,
341    ///Property: Topics
342    #[serde(skip_serializing_if = "Option::is_none")]
343    pub topics: Option<Vec<String>>,
344    ///Property: Type
345    #[serde(skip_serializing_if = "Option::is_none")]
346    pub type_: Option<Vec<String>>,
347    ///Property: Weak alias
348    #[serde(skip_serializing_if = "Option::is_none")]
349    pub weak_alias: Option<Vec<String>>,
350    ///Property: Wikidata ID
351    #[serde(skip_serializing_if = "Option::is_none")]
352    pub wikidata_id: Option<Vec<String>>,
353    ///Property: Wikipedia Article
354    #[serde(skip_serializing_if = "Option::is_none")]
355    pub wikipedia_url: Option<Vec<String>>,
356}
357impl Airplane {
358    /// Create a new entity with the given ID
359    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
360    pub fn new(id: impl Into<String>) -> Self {
361        Self {
362            id: id.into(),
363            schema: "Airplane".to_string(),
364            address: None,
365            address_entity: None,
366            aleph_url: None,
367            alias: None,
368            amount: None,
369            amount_eur: None,
370            amount_usd: None,
371            build_date: None,
372            country: None,
373            created_at: None,
374            currency: None,
375            deregistration_date: None,
376            description: None,
377            icao_code: None,
378            index_text: None,
379            keywords: None,
380            manufacturer: None,
381            model: None,
382            modified_at: None,
383            name: Vec::new(),
384            notes: None,
385            operator: None,
386            owner: None,
387            previous_name: None,
388            program: None,
389            program_id: None,
390            proof: None,
391            publisher: None,
392            publisher_url: None,
393            registration_date: None,
394            registration_number: None,
395            retrieved_at: None,
396            serial_number: None,
397            source_url: None,
398            summary: None,
399            topics: None,
400            type_: None,
401            weak_alias: None,
402            wikidata_id: None,
403            wikipedia_url: None,
404        }
405    }
406    /// Get the schema name
407    pub fn schema_name() -> &'static str {
408        "Airplane"
409    }
410}
411///FTM Schema: Article
412#[derive(Debug, Clone, Serialize, Deserialize)]
413#[cfg_attr(feature = "builder", derive(Builder))]
414#[serde(rename_all = "camelCase")]
415pub struct Article {
416    pub id: String,
417    #[cfg_attr(feature = "builder", builder(default = "Article".to_string()))]
418    pub schema: String,
419    ///Property: Address
420    #[serde(skip_serializing_if = "Option::is_none")]
421    pub address: Option<Vec<String>>,
422    ///Property: Address
423    #[serde(skip_serializing_if = "Option::is_none")]
424    pub address_entity: Option<Vec<String>>,
425    ///Property: Aleph URL
426    #[serde(skip_serializing_if = "Option::is_none")]
427    pub aleph_url: Option<Vec<String>>,
428    ///Property: Alias
429    #[serde(skip_serializing_if = "Option::is_none")]
430    pub alias: Option<Vec<String>>,
431    ///Property: Ancestors
432    #[serde(skip_serializing_if = "Option::is_none")]
433    pub ancestors: Option<Vec<String>>,
434    ///Property: Author
435    #[serde(skip_serializing_if = "Option::is_none")]
436    pub author: Option<Vec<String>>,
437    ///Property: Authored on
438    #[serde(skip_serializing_if = "Option::is_none")]
439    pub authored_at: Option<Vec<String>>,
440    ///Property: Text
441    #[serde(skip_serializing_if = "Option::is_none")]
442    pub body_text: Option<Vec<String>>,
443    ///Property: Detected companies
444    #[serde(skip_serializing_if = "Option::is_none")]
445    pub companies_mentioned: Option<Vec<String>>,
446    ///Property: Checksum
447    #[serde(skip_serializing_if = "Option::is_none")]
448    pub content_hash: Option<Vec<String>>,
449    ///Property: Country
450    #[serde(skip_serializing_if = "Option::is_none")]
451    pub country: Option<Vec<String>>,
452    ///Property: Crawler
453    #[serde(skip_serializing_if = "Option::is_none")]
454    pub crawler: Option<Vec<String>>,
455    ///Property: Created at
456    #[serde(skip_serializing_if = "Option::is_none")]
457    pub created_at: Option<Vec<String>>,
458    ///Property: Date
459    #[serde(skip_serializing_if = "Option::is_none")]
460    pub date: Option<Vec<String>>,
461    ///Property: Description
462    #[serde(skip_serializing_if = "Option::is_none")]
463    pub description: Option<Vec<String>>,
464    ///Property: Detected country
465    #[serde(skip_serializing_if = "Option::is_none")]
466    pub detected_country: Option<Vec<String>>,
467    ///Property: Detected language
468    #[serde(skip_serializing_if = "Option::is_none")]
469    pub detected_language: Option<Vec<String>>,
470    ///Property: Detected e-mail addresses
471    #[serde(skip_serializing_if = "Option::is_none")]
472    pub email_mentioned: Option<Vec<String>>,
473    ///Property: File encoding
474    #[serde(skip_serializing_if = "Option::is_none")]
475    pub encoding: Option<Vec<String>>,
476    ///Property: File extension
477    #[serde(skip_serializing_if = "Option::is_none")]
478    pub extension: Option<Vec<String>>,
479    ///Property: File name
480    #[serde(default)]
481    pub file_name: Vec<String>,
482    ///Property: File size
483    #[serde(
484        skip_serializing_if = "Option::is_none",
485        deserialize_with = "deserialize_opt_f64_vec",
486        default
487    )]
488    pub file_size: Option<Vec<f64>>,
489    ///Property: Generator
490    #[serde(skip_serializing_if = "Option::is_none")]
491    pub generator: Option<Vec<String>>,
492    ///Property: Detected IBANs
493    #[serde(skip_serializing_if = "Option::is_none")]
494    pub iban_mentioned: Option<Vec<String>>,
495    ///Property: Index text
496    #[serde(skip_serializing_if = "Option::is_none")]
497    pub index_text: Option<Vec<String>>,
498    ///Property: Detected IP addresses
499    #[serde(skip_serializing_if = "Option::is_none")]
500    pub ip_mentioned: Option<Vec<String>>,
501    ///Property: Keywords
502    #[serde(skip_serializing_if = "Option::is_none")]
503    pub keywords: Option<Vec<String>>,
504    ///Property: Language
505    #[serde(skip_serializing_if = "Option::is_none")]
506    pub language: Option<Vec<String>>,
507    ///Property: Detected locations
508    #[serde(skip_serializing_if = "Option::is_none")]
509    pub location_mentioned: Option<Vec<String>>,
510    ///Property: Message ID
511    #[serde(skip_serializing_if = "Option::is_none")]
512    pub message_id: Option<Vec<String>>,
513    ///Property: MIME type
514    #[serde(skip_serializing_if = "Option::is_none")]
515    pub mime_type: Option<Vec<String>>,
516    ///Property: Modified on
517    #[serde(skip_serializing_if = "Option::is_none")]
518    pub modified_at: Option<Vec<String>>,
519    ///Property: Name
520    #[serde(default)]
521    pub name: Vec<String>,
522    ///Property: Detected names
523    #[serde(skip_serializing_if = "Option::is_none")]
524    pub names_mentioned: Option<Vec<String>>,
525    ///Property: Notes
526    #[serde(skip_serializing_if = "Option::is_none")]
527    pub notes: Option<Vec<String>>,
528    ///Property: Folder
529    #[serde(skip_serializing_if = "Option::is_none")]
530    pub parent: Option<Vec<String>>,
531    ///Property: Detected people
532    #[serde(skip_serializing_if = "Option::is_none")]
533    pub people_mentioned: Option<Vec<String>>,
534    ///Property: Detected phones
535    #[serde(skip_serializing_if = "Option::is_none")]
536    pub phone_mentioned: Option<Vec<String>>,
537    ///Property: Previous name
538    #[serde(skip_serializing_if = "Option::is_none")]
539    pub previous_name: Option<Vec<String>>,
540    ///Property: Processed at
541    #[serde(skip_serializing_if = "Option::is_none")]
542    pub processed_at: Option<Vec<String>>,
543    ///Property: Processing agent
544    #[serde(skip_serializing_if = "Option::is_none")]
545    pub processing_agent: Option<Vec<String>>,
546    ///Property: Processing error
547    #[serde(skip_serializing_if = "Option::is_none")]
548    pub processing_error: Option<Vec<String>>,
549    ///Property: Processing status
550    #[serde(skip_serializing_if = "Option::is_none")]
551    pub processing_status: Option<Vec<String>>,
552    ///Property: Program
553    #[serde(skip_serializing_if = "Option::is_none")]
554    pub program: Option<Vec<String>>,
555    ///Property: Program ID
556    #[serde(skip_serializing_if = "Option::is_none")]
557    pub program_id: Option<Vec<String>>,
558    ///Property: Source document
559    #[serde(skip_serializing_if = "Option::is_none")]
560    pub proof: Option<Vec<String>>,
561    ///Property: Published on
562    #[serde(skip_serializing_if = "Option::is_none")]
563    pub published_at: Option<Vec<String>>,
564    ///Property: Publishing source
565    #[serde(skip_serializing_if = "Option::is_none")]
566    pub publisher: Option<Vec<String>>,
567    ///Property: Publishing source URL
568    #[serde(skip_serializing_if = "Option::is_none")]
569    pub publisher_url: Option<Vec<String>>,
570    ///Property: Retrieved on
571    #[serde(skip_serializing_if = "Option::is_none")]
572    pub retrieved_at: Option<Vec<String>>,
573    ///Property: Source link
574    #[serde(skip_serializing_if = "Option::is_none")]
575    pub source_url: Option<Vec<String>>,
576    ///Property: Summary
577    #[serde(skip_serializing_if = "Option::is_none")]
578    pub summary: Option<Vec<String>>,
579    ///Property: Title
580    #[serde(skip_serializing_if = "Option::is_none")]
581    pub title: Option<Vec<String>>,
582    ///Property: Topics
583    #[serde(skip_serializing_if = "Option::is_none")]
584    pub topics: Option<Vec<String>>,
585    ///Property: The language of the translated text
586    #[serde(skip_serializing_if = "Option::is_none")]
587    pub translated_language: Option<Vec<String>>,
588    ///Property: Translated version of the body text
589    #[serde(skip_serializing_if = "Option::is_none")]
590    pub translated_text: Option<Vec<String>>,
591    ///Property: Weak alias
592    #[serde(skip_serializing_if = "Option::is_none")]
593    pub weak_alias: Option<Vec<String>>,
594    ///Property: Wikidata ID
595    #[serde(skip_serializing_if = "Option::is_none")]
596    pub wikidata_id: Option<Vec<String>>,
597    ///Property: Wikipedia Article
598    #[serde(skip_serializing_if = "Option::is_none")]
599    pub wikipedia_url: Option<Vec<String>>,
600}
601impl Article {
602    /// Create a new entity with the given ID
603    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
604    pub fn new(id: impl Into<String>) -> Self {
605        Self {
606            id: id.into(),
607            schema: "Article".to_string(),
608            address: None,
609            address_entity: None,
610            aleph_url: None,
611            alias: None,
612            ancestors: None,
613            author: None,
614            authored_at: None,
615            body_text: None,
616            companies_mentioned: None,
617            content_hash: None,
618            country: None,
619            crawler: None,
620            created_at: None,
621            date: None,
622            description: None,
623            detected_country: None,
624            detected_language: None,
625            email_mentioned: None,
626            encoding: None,
627            extension: None,
628            file_name: Vec::new(),
629            file_size: None,
630            generator: None,
631            iban_mentioned: None,
632            index_text: None,
633            ip_mentioned: None,
634            keywords: None,
635            language: None,
636            location_mentioned: None,
637            message_id: None,
638            mime_type: None,
639            modified_at: None,
640            name: Vec::new(),
641            names_mentioned: None,
642            notes: None,
643            parent: None,
644            people_mentioned: None,
645            phone_mentioned: None,
646            previous_name: None,
647            processed_at: None,
648            processing_agent: None,
649            processing_error: None,
650            processing_status: None,
651            program: None,
652            program_id: None,
653            proof: None,
654            published_at: None,
655            publisher: None,
656            publisher_url: None,
657            retrieved_at: None,
658            source_url: None,
659            summary: None,
660            title: None,
661            topics: None,
662            translated_language: None,
663            translated_text: None,
664            weak_alias: None,
665            wikidata_id: None,
666            wikipedia_url: None,
667        }
668    }
669    /// Get the schema name
670    pub fn schema_name() -> &'static str {
671        "Article"
672    }
673}
674///FTM Schema: Asset
675#[derive(Debug, Clone, Serialize, Deserialize)]
676#[cfg_attr(feature = "builder", derive(Builder))]
677#[serde(rename_all = "camelCase")]
678pub struct Asset {
679    pub id: String,
680    #[cfg_attr(feature = "builder", builder(default = "Asset".to_string()))]
681    pub schema: String,
682    ///Property: Address
683    #[serde(skip_serializing_if = "Option::is_none")]
684    pub address: Option<Vec<String>>,
685    ///Property: Address
686    #[serde(skip_serializing_if = "Option::is_none")]
687    pub address_entity: Option<Vec<String>>,
688    ///Property: Aleph URL
689    #[serde(skip_serializing_if = "Option::is_none")]
690    pub aleph_url: Option<Vec<String>>,
691    ///Property: Alias
692    #[serde(skip_serializing_if = "Option::is_none")]
693    pub alias: Option<Vec<String>>,
694    ///Property: Amount
695    #[serde(
696        skip_serializing_if = "Option::is_none",
697        deserialize_with = "deserialize_opt_f64_vec",
698        default
699    )]
700    pub amount: Option<Vec<f64>>,
701    ///Property: Amount in EUR
702    #[serde(
703        skip_serializing_if = "Option::is_none",
704        deserialize_with = "deserialize_opt_f64_vec",
705        default
706    )]
707    pub amount_eur: Option<Vec<f64>>,
708    ///Property: Amount in USD
709    #[serde(
710        skip_serializing_if = "Option::is_none",
711        deserialize_with = "deserialize_opt_f64_vec",
712        default
713    )]
714    pub amount_usd: Option<Vec<f64>>,
715    ///Property: Country
716    #[serde(skip_serializing_if = "Option::is_none")]
717    pub country: Option<Vec<String>>,
718    ///Property: Created at
719    #[serde(skip_serializing_if = "Option::is_none")]
720    pub created_at: Option<Vec<String>>,
721    ///Property: Currency
722    #[serde(skip_serializing_if = "Option::is_none")]
723    pub currency: Option<Vec<String>>,
724    ///Property: Description
725    #[serde(skip_serializing_if = "Option::is_none")]
726    pub description: Option<Vec<String>>,
727    ///Property: Index text
728    #[serde(skip_serializing_if = "Option::is_none")]
729    pub index_text: Option<Vec<String>>,
730    ///Property: Keywords
731    #[serde(skip_serializing_if = "Option::is_none")]
732    pub keywords: Option<Vec<String>>,
733    ///Property: Modified on
734    #[serde(skip_serializing_if = "Option::is_none")]
735    pub modified_at: Option<Vec<String>>,
736    ///Property: Name
737    #[serde(default)]
738    pub name: Vec<String>,
739    ///Property: Notes
740    #[serde(skip_serializing_if = "Option::is_none")]
741    pub notes: Option<Vec<String>>,
742    ///Property: Previous name
743    #[serde(skip_serializing_if = "Option::is_none")]
744    pub previous_name: Option<Vec<String>>,
745    ///Property: Program
746    #[serde(skip_serializing_if = "Option::is_none")]
747    pub program: Option<Vec<String>>,
748    ///Property: Program ID
749    #[serde(skip_serializing_if = "Option::is_none")]
750    pub program_id: Option<Vec<String>>,
751    ///Property: Source document
752    #[serde(skip_serializing_if = "Option::is_none")]
753    pub proof: Option<Vec<String>>,
754    ///Property: Publishing source
755    #[serde(skip_serializing_if = "Option::is_none")]
756    pub publisher: Option<Vec<String>>,
757    ///Property: Publishing source URL
758    #[serde(skip_serializing_if = "Option::is_none")]
759    pub publisher_url: Option<Vec<String>>,
760    ///Property: Retrieved on
761    #[serde(skip_serializing_if = "Option::is_none")]
762    pub retrieved_at: Option<Vec<String>>,
763    ///Property: Source link
764    #[serde(skip_serializing_if = "Option::is_none")]
765    pub source_url: Option<Vec<String>>,
766    ///Property: Summary
767    #[serde(skip_serializing_if = "Option::is_none")]
768    pub summary: Option<Vec<String>>,
769    ///Property: Topics
770    #[serde(skip_serializing_if = "Option::is_none")]
771    pub topics: Option<Vec<String>>,
772    ///Property: Weak alias
773    #[serde(skip_serializing_if = "Option::is_none")]
774    pub weak_alias: Option<Vec<String>>,
775    ///Property: Wikidata ID
776    #[serde(skip_serializing_if = "Option::is_none")]
777    pub wikidata_id: Option<Vec<String>>,
778    ///Property: Wikipedia Article
779    #[serde(skip_serializing_if = "Option::is_none")]
780    pub wikipedia_url: Option<Vec<String>>,
781}
782impl Asset {
783    /// Create a new entity with the given ID
784    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
785    pub fn new(id: impl Into<String>) -> Self {
786        Self {
787            id: id.into(),
788            schema: "Asset".to_string(),
789            address: None,
790            address_entity: None,
791            aleph_url: None,
792            alias: None,
793            amount: None,
794            amount_eur: None,
795            amount_usd: None,
796            country: None,
797            created_at: None,
798            currency: None,
799            description: None,
800            index_text: None,
801            keywords: None,
802            modified_at: None,
803            name: Vec::new(),
804            notes: None,
805            previous_name: None,
806            program: None,
807            program_id: None,
808            proof: None,
809            publisher: None,
810            publisher_url: None,
811            retrieved_at: None,
812            source_url: None,
813            summary: None,
814            topics: None,
815            weak_alias: None,
816            wikidata_id: None,
817            wikipedia_url: None,
818        }
819    }
820    /// Get the schema name
821    pub fn schema_name() -> &'static str {
822        "Asset"
823    }
824}
825///FTM Schema: Associate
826#[derive(Debug, Clone, Serialize, Deserialize)]
827#[cfg_attr(feature = "builder", derive(Builder))]
828#[serde(rename_all = "camelCase")]
829pub struct Associate {
830    pub id: String,
831    #[cfg_attr(feature = "builder", builder(default = "Associate".to_string()))]
832    pub schema: String,
833    ///Property: Aleph URL
834    #[serde(skip_serializing_if = "Option::is_none")]
835    pub aleph_url: Option<Vec<String>>,
836    ///Property: Associate
837    #[serde(default)]
838    pub associate: Vec<String>,
839    ///Property: Date
840    #[serde(skip_serializing_if = "Option::is_none")]
841    pub date: Option<Vec<String>>,
842    ///Property: Description
843    #[serde(skip_serializing_if = "Option::is_none")]
844    pub description: Option<Vec<String>>,
845    ///Property: End date
846    #[serde(skip_serializing_if = "Option::is_none")]
847    pub end_date: Option<Vec<String>>,
848    ///Property: Index text
849    #[serde(skip_serializing_if = "Option::is_none")]
850    pub index_text: Option<Vec<String>>,
851    ///Property: Modified on
852    #[serde(skip_serializing_if = "Option::is_none")]
853    pub modified_at: Option<Vec<String>>,
854    ///Property: Detected names
855    #[serde(skip_serializing_if = "Option::is_none")]
856    pub names_mentioned: Option<Vec<String>>,
857    ///Property: Person
858    #[serde(default)]
859    pub person: Vec<String>,
860    ///Property: Source document
861    #[serde(skip_serializing_if = "Option::is_none")]
862    pub proof: Option<Vec<String>>,
863    ///Property: Publishing source
864    #[serde(skip_serializing_if = "Option::is_none")]
865    pub publisher: Option<Vec<String>>,
866    ///Property: Publishing source URL
867    #[serde(skip_serializing_if = "Option::is_none")]
868    pub publisher_url: Option<Vec<String>>,
869    ///Property: Record ID
870    #[serde(skip_serializing_if = "Option::is_none")]
871    pub record_id: Option<Vec<String>>,
872    ///Property: Relationship
873    #[serde(skip_serializing_if = "Option::is_none")]
874    pub relationship: Option<Vec<String>>,
875    ///Property: Retrieved on
876    #[serde(skip_serializing_if = "Option::is_none")]
877    pub retrieved_at: Option<Vec<String>>,
878    ///Property: Source link
879    #[serde(skip_serializing_if = "Option::is_none")]
880    pub source_url: Option<Vec<String>>,
881    ///Property: Start date
882    #[serde(skip_serializing_if = "Option::is_none")]
883    pub start_date: Option<Vec<String>>,
884    ///Property: Summary
885    #[serde(skip_serializing_if = "Option::is_none")]
886    pub summary: Option<Vec<String>>,
887}
888impl Associate {
889    /// Create a new entity with the given ID
890    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
891    pub fn new(id: impl Into<String>) -> Self {
892        Self {
893            id: id.into(),
894            schema: "Associate".to_string(),
895            aleph_url: None,
896            associate: Vec::new(),
897            date: None,
898            description: None,
899            end_date: None,
900            index_text: None,
901            modified_at: None,
902            names_mentioned: None,
903            person: Vec::new(),
904            proof: None,
905            publisher: None,
906            publisher_url: None,
907            record_id: None,
908            relationship: None,
909            retrieved_at: None,
910            source_url: None,
911            start_date: None,
912            summary: None,
913        }
914    }
915    /// Get the schema name
916    pub fn schema_name() -> &'static str {
917        "Associate"
918    }
919}
920///FTM Schema: Audio
921#[derive(Debug, Clone, Serialize, Deserialize)]
922#[cfg_attr(feature = "builder", derive(Builder))]
923#[serde(rename_all = "camelCase")]
924pub struct Audio {
925    pub id: String,
926    #[cfg_attr(feature = "builder", builder(default = "Audio".to_string()))]
927    pub schema: String,
928    ///Property: Address
929    #[serde(skip_serializing_if = "Option::is_none")]
930    pub address: Option<Vec<String>>,
931    ///Property: Address
932    #[serde(skip_serializing_if = "Option::is_none")]
933    pub address_entity: Option<Vec<String>>,
934    ///Property: Aleph URL
935    #[serde(skip_serializing_if = "Option::is_none")]
936    pub aleph_url: Option<Vec<String>>,
937    ///Property: Alias
938    #[serde(skip_serializing_if = "Option::is_none")]
939    pub alias: Option<Vec<String>>,
940    ///Property: Ancestors
941    #[serde(skip_serializing_if = "Option::is_none")]
942    pub ancestors: Option<Vec<String>>,
943    ///Property: Author
944    #[serde(skip_serializing_if = "Option::is_none")]
945    pub author: Option<Vec<String>>,
946    ///Property: Authored on
947    #[serde(skip_serializing_if = "Option::is_none")]
948    pub authored_at: Option<Vec<String>>,
949    ///Property: Text
950    #[serde(skip_serializing_if = "Option::is_none")]
951    pub body_text: Option<Vec<String>>,
952    ///Property: Detected companies
953    #[serde(skip_serializing_if = "Option::is_none")]
954    pub companies_mentioned: Option<Vec<String>>,
955    ///Property: Checksum
956    #[serde(skip_serializing_if = "Option::is_none")]
957    pub content_hash: Option<Vec<String>>,
958    ///Property: Country
959    #[serde(skip_serializing_if = "Option::is_none")]
960    pub country: Option<Vec<String>>,
961    ///Property: Crawler
962    #[serde(skip_serializing_if = "Option::is_none")]
963    pub crawler: Option<Vec<String>>,
964    ///Property: Created at
965    #[serde(skip_serializing_if = "Option::is_none")]
966    pub created_at: Option<Vec<String>>,
967    ///Property: Date
968    #[serde(skip_serializing_if = "Option::is_none")]
969    pub date: Option<Vec<String>>,
970    ///Property: Description
971    #[serde(skip_serializing_if = "Option::is_none")]
972    pub description: Option<Vec<String>>,
973    ///Property: Detected country
974    #[serde(skip_serializing_if = "Option::is_none")]
975    pub detected_country: Option<Vec<String>>,
976    ///Property: Detected language
977    #[serde(skip_serializing_if = "Option::is_none")]
978    pub detected_language: Option<Vec<String>>,
979    ///Property: Duration
980    #[serde(
981        skip_serializing_if = "Option::is_none",
982        deserialize_with = "deserialize_opt_f64_vec",
983        default
984    )]
985    pub duration: Option<Vec<f64>>,
986    ///Property: Detected e-mail addresses
987    #[serde(skip_serializing_if = "Option::is_none")]
988    pub email_mentioned: Option<Vec<String>>,
989    ///Property: File encoding
990    #[serde(skip_serializing_if = "Option::is_none")]
991    pub encoding: Option<Vec<String>>,
992    ///Property: File extension
993    #[serde(skip_serializing_if = "Option::is_none")]
994    pub extension: Option<Vec<String>>,
995    ///Property: File name
996    #[serde(default)]
997    pub file_name: Vec<String>,
998    ///Property: File size
999    #[serde(
1000        skip_serializing_if = "Option::is_none",
1001        deserialize_with = "deserialize_opt_f64_vec",
1002        default
1003    )]
1004    pub file_size: Option<Vec<f64>>,
1005    ///Property: Generator
1006    #[serde(skip_serializing_if = "Option::is_none")]
1007    pub generator: Option<Vec<String>>,
1008    ///Property: Detected IBANs
1009    #[serde(skip_serializing_if = "Option::is_none")]
1010    pub iban_mentioned: Option<Vec<String>>,
1011    ///Property: Index text
1012    #[serde(skip_serializing_if = "Option::is_none")]
1013    pub index_text: Option<Vec<String>>,
1014    ///Property: Detected IP addresses
1015    #[serde(skip_serializing_if = "Option::is_none")]
1016    pub ip_mentioned: Option<Vec<String>>,
1017    ///Property: Keywords
1018    #[serde(skip_serializing_if = "Option::is_none")]
1019    pub keywords: Option<Vec<String>>,
1020    ///Property: Language
1021    #[serde(skip_serializing_if = "Option::is_none")]
1022    pub language: Option<Vec<String>>,
1023    ///Property: Detected locations
1024    #[serde(skip_serializing_if = "Option::is_none")]
1025    pub location_mentioned: Option<Vec<String>>,
1026    ///Property: Message ID
1027    #[serde(skip_serializing_if = "Option::is_none")]
1028    pub message_id: Option<Vec<String>>,
1029    ///Property: MIME type
1030    #[serde(skip_serializing_if = "Option::is_none")]
1031    pub mime_type: Option<Vec<String>>,
1032    ///Property: Modified on
1033    #[serde(skip_serializing_if = "Option::is_none")]
1034    pub modified_at: Option<Vec<String>>,
1035    ///Property: Name
1036    #[serde(default)]
1037    pub name: Vec<String>,
1038    ///Property: Detected names
1039    #[serde(skip_serializing_if = "Option::is_none")]
1040    pub names_mentioned: Option<Vec<String>>,
1041    ///Property: Notes
1042    #[serde(skip_serializing_if = "Option::is_none")]
1043    pub notes: Option<Vec<String>>,
1044    ///Property: Folder
1045    #[serde(skip_serializing_if = "Option::is_none")]
1046    pub parent: Option<Vec<String>>,
1047    ///Property: Detected people
1048    #[serde(skip_serializing_if = "Option::is_none")]
1049    pub people_mentioned: Option<Vec<String>>,
1050    ///Property: Detected phones
1051    #[serde(skip_serializing_if = "Option::is_none")]
1052    pub phone_mentioned: Option<Vec<String>>,
1053    ///Property: Previous name
1054    #[serde(skip_serializing_if = "Option::is_none")]
1055    pub previous_name: Option<Vec<String>>,
1056    ///Property: Processed at
1057    #[serde(skip_serializing_if = "Option::is_none")]
1058    pub processed_at: Option<Vec<String>>,
1059    ///Property: Processing agent
1060    #[serde(skip_serializing_if = "Option::is_none")]
1061    pub processing_agent: Option<Vec<String>>,
1062    ///Property: Processing error
1063    #[serde(skip_serializing_if = "Option::is_none")]
1064    pub processing_error: Option<Vec<String>>,
1065    ///Property: Processing status
1066    #[serde(skip_serializing_if = "Option::is_none")]
1067    pub processing_status: Option<Vec<String>>,
1068    ///Property: Program
1069    #[serde(skip_serializing_if = "Option::is_none")]
1070    pub program: Option<Vec<String>>,
1071    ///Property: Program ID
1072    #[serde(skip_serializing_if = "Option::is_none")]
1073    pub program_id: Option<Vec<String>>,
1074    ///Property: Source document
1075    #[serde(skip_serializing_if = "Option::is_none")]
1076    pub proof: Option<Vec<String>>,
1077    ///Property: Published on
1078    #[serde(skip_serializing_if = "Option::is_none")]
1079    pub published_at: Option<Vec<String>>,
1080    ///Property: Publishing source
1081    #[serde(skip_serializing_if = "Option::is_none")]
1082    pub publisher: Option<Vec<String>>,
1083    ///Property: Publishing source URL
1084    #[serde(skip_serializing_if = "Option::is_none")]
1085    pub publisher_url: Option<Vec<String>>,
1086    ///Property: Retrieved on
1087    #[serde(skip_serializing_if = "Option::is_none")]
1088    pub retrieved_at: Option<Vec<String>>,
1089    ///Property: Sampling Rate
1090    #[serde(
1091        skip_serializing_if = "Option::is_none",
1092        deserialize_with = "deserialize_opt_f64_vec",
1093        default
1094    )]
1095    pub sampling_rate: Option<Vec<f64>>,
1096    ///Property: Source link
1097    #[serde(skip_serializing_if = "Option::is_none")]
1098    pub source_url: Option<Vec<String>>,
1099    ///Property: Summary
1100    #[serde(skip_serializing_if = "Option::is_none")]
1101    pub summary: Option<Vec<String>>,
1102    ///Property: Title
1103    #[serde(skip_serializing_if = "Option::is_none")]
1104    pub title: Option<Vec<String>>,
1105    ///Property: Topics
1106    #[serde(skip_serializing_if = "Option::is_none")]
1107    pub topics: Option<Vec<String>>,
1108    ///Property: The language of the translated text
1109    #[serde(skip_serializing_if = "Option::is_none")]
1110    pub translated_language: Option<Vec<String>>,
1111    ///Property: Translated version of the body text
1112    #[serde(skip_serializing_if = "Option::is_none")]
1113    pub translated_text: Option<Vec<String>>,
1114    ///Property: Weak alias
1115    #[serde(skip_serializing_if = "Option::is_none")]
1116    pub weak_alias: Option<Vec<String>>,
1117    ///Property: Wikidata ID
1118    #[serde(skip_serializing_if = "Option::is_none")]
1119    pub wikidata_id: Option<Vec<String>>,
1120    ///Property: Wikipedia Article
1121    #[serde(skip_serializing_if = "Option::is_none")]
1122    pub wikipedia_url: Option<Vec<String>>,
1123}
1124impl Audio {
1125    /// Create a new entity with the given ID
1126    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
1127    pub fn new(id: impl Into<String>) -> Self {
1128        Self {
1129            id: id.into(),
1130            schema: "Audio".to_string(),
1131            address: None,
1132            address_entity: None,
1133            aleph_url: None,
1134            alias: None,
1135            ancestors: None,
1136            author: None,
1137            authored_at: None,
1138            body_text: None,
1139            companies_mentioned: None,
1140            content_hash: None,
1141            country: None,
1142            crawler: None,
1143            created_at: None,
1144            date: None,
1145            description: None,
1146            detected_country: None,
1147            detected_language: None,
1148            duration: None,
1149            email_mentioned: None,
1150            encoding: None,
1151            extension: None,
1152            file_name: Vec::new(),
1153            file_size: None,
1154            generator: None,
1155            iban_mentioned: None,
1156            index_text: None,
1157            ip_mentioned: None,
1158            keywords: None,
1159            language: None,
1160            location_mentioned: None,
1161            message_id: None,
1162            mime_type: None,
1163            modified_at: None,
1164            name: Vec::new(),
1165            names_mentioned: None,
1166            notes: None,
1167            parent: None,
1168            people_mentioned: None,
1169            phone_mentioned: None,
1170            previous_name: None,
1171            processed_at: None,
1172            processing_agent: None,
1173            processing_error: None,
1174            processing_status: None,
1175            program: None,
1176            program_id: None,
1177            proof: None,
1178            published_at: None,
1179            publisher: None,
1180            publisher_url: None,
1181            retrieved_at: None,
1182            sampling_rate: None,
1183            source_url: None,
1184            summary: None,
1185            title: None,
1186            topics: None,
1187            translated_language: None,
1188            translated_text: None,
1189            weak_alias: None,
1190            wikidata_id: None,
1191            wikipedia_url: None,
1192        }
1193    }
1194    /// Get the schema name
1195    pub fn schema_name() -> &'static str {
1196        "Audio"
1197    }
1198}
1199///FTM Schema: Bank account
1200#[derive(Debug, Clone, Serialize, Deserialize)]
1201#[cfg_attr(feature = "builder", derive(Builder))]
1202#[serde(rename_all = "camelCase")]
1203pub struct BankAccount {
1204    pub id: String,
1205    #[cfg_attr(feature = "builder", builder(default = "BankAccount".to_string()))]
1206    pub schema: String,
1207    ///Property: Account number
1208    #[serde(skip_serializing_if = "Option::is_none")]
1209    pub account_number: Option<Vec<String>>,
1210    ///Property: Account type
1211    #[serde(skip_serializing_if = "Option::is_none")]
1212    pub account_type: Option<Vec<String>>,
1213    ///Property: Address
1214    #[serde(skip_serializing_if = "Option::is_none")]
1215    pub address: Option<Vec<String>>,
1216    ///Property: Address
1217    #[serde(skip_serializing_if = "Option::is_none")]
1218    pub address_entity: Option<Vec<String>>,
1219    ///Property: Aleph URL
1220    #[serde(skip_serializing_if = "Option::is_none")]
1221    pub aleph_url: Option<Vec<String>>,
1222    ///Property: Alias
1223    #[serde(skip_serializing_if = "Option::is_none")]
1224    pub alias: Option<Vec<String>>,
1225    ///Property: Amount
1226    #[serde(
1227        skip_serializing_if = "Option::is_none",
1228        deserialize_with = "deserialize_opt_f64_vec",
1229        default
1230    )]
1231    pub amount: Option<Vec<f64>>,
1232    ///Property: Amount in EUR
1233    #[serde(
1234        skip_serializing_if = "Option::is_none",
1235        deserialize_with = "deserialize_opt_f64_vec",
1236        default
1237    )]
1238    pub amount_eur: Option<Vec<f64>>,
1239    ///Property: Amount in USD
1240    #[serde(
1241        skip_serializing_if = "Option::is_none",
1242        deserialize_with = "deserialize_opt_f64_vec",
1243        default
1244    )]
1245    pub amount_usd: Option<Vec<f64>>,
1246    ///Property: Balance
1247    #[serde(
1248        skip_serializing_if = "Option::is_none",
1249        deserialize_with = "deserialize_opt_f64_vec",
1250        default
1251    )]
1252    pub balance: Option<Vec<f64>>,
1253    ///Property: Balance date
1254    #[serde(skip_serializing_if = "Option::is_none")]
1255    pub balance_date: Option<Vec<String>>,
1256    ///Property: Bank
1257    #[serde(skip_serializing_if = "Option::is_none")]
1258    pub bank: Option<Vec<String>>,
1259    ///Property: Bank address
1260    #[serde(skip_serializing_if = "Option::is_none")]
1261    pub bank_address: Option<Vec<String>>,
1262    ///Property: Bank name
1263    #[serde(skip_serializing_if = "Option::is_none")]
1264    pub bank_name: Option<Vec<String>>,
1265    ///Property: Bank Identifier Code
1266    #[serde(skip_serializing_if = "Option::is_none")]
1267    pub bic: Option<Vec<String>>,
1268    ///Property: Closing date
1269    #[serde(skip_serializing_if = "Option::is_none")]
1270    pub closing_date: Option<Vec<String>>,
1271    ///Property: Country
1272    #[serde(skip_serializing_if = "Option::is_none")]
1273    pub country: Option<Vec<String>>,
1274    ///Property: Created at
1275    #[serde(skip_serializing_if = "Option::is_none")]
1276    pub created_at: Option<Vec<String>>,
1277    ///Property: Currency
1278    #[serde(skip_serializing_if = "Option::is_none")]
1279    pub currency: Option<Vec<String>>,
1280    ///Property: Description
1281    #[serde(skip_serializing_if = "Option::is_none")]
1282    pub description: Option<Vec<String>>,
1283    ///Property: IBAN
1284    #[serde(skip_serializing_if = "Option::is_none")]
1285    pub iban: Option<Vec<String>>,
1286    ///Property: Index text
1287    #[serde(skip_serializing_if = "Option::is_none")]
1288    pub index_text: Option<Vec<String>>,
1289    ///Property: Keywords
1290    #[serde(skip_serializing_if = "Option::is_none")]
1291    pub keywords: Option<Vec<String>>,
1292    ///Property: Maximum balance
1293    #[serde(
1294        skip_serializing_if = "Option::is_none",
1295        deserialize_with = "deserialize_opt_f64_vec",
1296        default
1297    )]
1298    pub max_balance: Option<Vec<f64>>,
1299    ///Property: Maximum balance date
1300    #[serde(skip_serializing_if = "Option::is_none")]
1301    pub max_balance_date: Option<Vec<String>>,
1302    ///Property: Modified on
1303    #[serde(skip_serializing_if = "Option::is_none")]
1304    pub modified_at: Option<Vec<String>>,
1305    ///Property: Name
1306    #[serde(default)]
1307    pub name: Vec<String>,
1308    ///Property: Notes
1309    #[serde(skip_serializing_if = "Option::is_none")]
1310    pub notes: Option<Vec<String>>,
1311    ///Property: Opening date
1312    #[serde(skip_serializing_if = "Option::is_none")]
1313    pub opening_date: Option<Vec<String>>,
1314    ///Property: Previous name
1315    #[serde(skip_serializing_if = "Option::is_none")]
1316    pub previous_name: Option<Vec<String>>,
1317    ///Property: Program
1318    #[serde(skip_serializing_if = "Option::is_none")]
1319    pub program: Option<Vec<String>>,
1320    ///Property: Program ID
1321    #[serde(skip_serializing_if = "Option::is_none")]
1322    pub program_id: Option<Vec<String>>,
1323    ///Property: Source document
1324    #[serde(skip_serializing_if = "Option::is_none")]
1325    pub proof: Option<Vec<String>>,
1326    ///Property: Publishing source
1327    #[serde(skip_serializing_if = "Option::is_none")]
1328    pub publisher: Option<Vec<String>>,
1329    ///Property: Publishing source URL
1330    #[serde(skip_serializing_if = "Option::is_none")]
1331    pub publisher_url: Option<Vec<String>>,
1332    ///Property: Retrieved on
1333    #[serde(skip_serializing_if = "Option::is_none")]
1334    pub retrieved_at: Option<Vec<String>>,
1335    ///Property: Source link
1336    #[serde(skip_serializing_if = "Option::is_none")]
1337    pub source_url: Option<Vec<String>>,
1338    ///Property: Summary
1339    #[serde(skip_serializing_if = "Option::is_none")]
1340    pub summary: Option<Vec<String>>,
1341    ///Property: Topics
1342    #[serde(skip_serializing_if = "Option::is_none")]
1343    pub topics: Option<Vec<String>>,
1344    ///Property: Weak alias
1345    #[serde(skip_serializing_if = "Option::is_none")]
1346    pub weak_alias: Option<Vec<String>>,
1347    ///Property: Wikidata ID
1348    #[serde(skip_serializing_if = "Option::is_none")]
1349    pub wikidata_id: Option<Vec<String>>,
1350    ///Property: Wikipedia Article
1351    #[serde(skip_serializing_if = "Option::is_none")]
1352    pub wikipedia_url: Option<Vec<String>>,
1353}
1354impl BankAccount {
1355    /// Create a new entity with the given ID
1356    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
1357    pub fn new(id: impl Into<String>) -> Self {
1358        Self {
1359            id: id.into(),
1360            schema: "BankAccount".to_string(),
1361            account_number: None,
1362            account_type: None,
1363            address: None,
1364            address_entity: None,
1365            aleph_url: None,
1366            alias: None,
1367            amount: None,
1368            amount_eur: None,
1369            amount_usd: None,
1370            balance: None,
1371            balance_date: None,
1372            bank: None,
1373            bank_address: None,
1374            bank_name: None,
1375            bic: None,
1376            closing_date: None,
1377            country: None,
1378            created_at: None,
1379            currency: None,
1380            description: None,
1381            iban: None,
1382            index_text: None,
1383            keywords: None,
1384            max_balance: None,
1385            max_balance_date: None,
1386            modified_at: None,
1387            name: Vec::new(),
1388            notes: None,
1389            opening_date: None,
1390            previous_name: None,
1391            program: None,
1392            program_id: None,
1393            proof: None,
1394            publisher: None,
1395            publisher_url: None,
1396            retrieved_at: None,
1397            source_url: None,
1398            summary: None,
1399            topics: None,
1400            weak_alias: None,
1401            wikidata_id: None,
1402            wikipedia_url: None,
1403        }
1404    }
1405    /// Get the schema name
1406    pub fn schema_name() -> &'static str {
1407        "BankAccount"
1408    }
1409}
1410///FTM Schema: Call
1411#[derive(Debug, Clone, Serialize, Deserialize)]
1412#[cfg_attr(feature = "builder", derive(Builder))]
1413#[serde(rename_all = "camelCase")]
1414pub struct Call {
1415    pub id: String,
1416    #[cfg_attr(feature = "builder", builder(default = "Call".to_string()))]
1417    pub schema: String,
1418    ///Property: Aleph URL
1419    #[serde(skip_serializing_if = "Option::is_none")]
1420    pub aleph_url: Option<Vec<String>>,
1421    ///Property: Caller
1422    #[serde(skip_serializing_if = "Option::is_none")]
1423    pub caller: Option<Vec<String>>,
1424    ///Property: Caller's Number
1425    #[serde(skip_serializing_if = "Option::is_none")]
1426    pub caller_number: Option<Vec<String>>,
1427    ///Property: Date
1428    #[serde(skip_serializing_if = "Option::is_none")]
1429    pub date: Option<Vec<String>>,
1430    ///Property: Description
1431    #[serde(skip_serializing_if = "Option::is_none")]
1432    pub description: Option<Vec<String>>,
1433    ///Property: Duration
1434    #[serde(
1435        skip_serializing_if = "Option::is_none",
1436        deserialize_with = "deserialize_opt_f64_vec",
1437        default
1438    )]
1439    pub duration: Option<Vec<f64>>,
1440    ///Property: End date
1441    #[serde(skip_serializing_if = "Option::is_none")]
1442    pub end_date: Option<Vec<String>>,
1443    ///Property: Index text
1444    #[serde(skip_serializing_if = "Option::is_none")]
1445    pub index_text: Option<Vec<String>>,
1446    ///Property: Modified on
1447    #[serde(skip_serializing_if = "Option::is_none")]
1448    pub modified_at: Option<Vec<String>>,
1449    ///Property: Detected names
1450    #[serde(skip_serializing_if = "Option::is_none")]
1451    pub names_mentioned: Option<Vec<String>>,
1452    ///Property: Source document
1453    #[serde(skip_serializing_if = "Option::is_none")]
1454    pub proof: Option<Vec<String>>,
1455    ///Property: Publishing source
1456    #[serde(skip_serializing_if = "Option::is_none")]
1457    pub publisher: Option<Vec<String>>,
1458    ///Property: Publishing source URL
1459    #[serde(skip_serializing_if = "Option::is_none")]
1460    pub publisher_url: Option<Vec<String>>,
1461    ///Property: Receiver
1462    #[serde(skip_serializing_if = "Option::is_none")]
1463    pub receiver: Option<Vec<String>>,
1464    ///Property: Receiver's Number
1465    #[serde(skip_serializing_if = "Option::is_none")]
1466    pub receiver_number: Option<Vec<String>>,
1467    ///Property: Record ID
1468    #[serde(skip_serializing_if = "Option::is_none")]
1469    pub record_id: Option<Vec<String>>,
1470    ///Property: Retrieved on
1471    #[serde(skip_serializing_if = "Option::is_none")]
1472    pub retrieved_at: Option<Vec<String>>,
1473    ///Property: Source link
1474    #[serde(skip_serializing_if = "Option::is_none")]
1475    pub source_url: Option<Vec<String>>,
1476    ///Property: Start date
1477    #[serde(skip_serializing_if = "Option::is_none")]
1478    pub start_date: Option<Vec<String>>,
1479    ///Property: Summary
1480    #[serde(skip_serializing_if = "Option::is_none")]
1481    pub summary: Option<Vec<String>>,
1482}
1483impl Call {
1484    /// Create a new entity with the given ID
1485    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
1486    pub fn new(id: impl Into<String>) -> Self {
1487        Self {
1488            id: id.into(),
1489            schema: "Call".to_string(),
1490            aleph_url: None,
1491            caller: None,
1492            caller_number: None,
1493            date: None,
1494            description: None,
1495            duration: None,
1496            end_date: None,
1497            index_text: None,
1498            modified_at: None,
1499            names_mentioned: None,
1500            proof: None,
1501            publisher: None,
1502            publisher_url: None,
1503            receiver: None,
1504            receiver_number: None,
1505            record_id: None,
1506            retrieved_at: None,
1507            source_url: None,
1508            start_date: None,
1509            summary: None,
1510        }
1511    }
1512    /// Get the schema name
1513    pub fn schema_name() -> &'static str {
1514        "Call"
1515    }
1516}
1517///FTM Schema: Call for tenders
1518#[derive(Debug, Clone, Serialize, Deserialize)]
1519#[cfg_attr(feature = "builder", derive(Builder))]
1520#[serde(rename_all = "camelCase")]
1521pub struct CallForTenders {
1522    pub id: String,
1523    #[cfg_attr(feature = "builder", builder(default = "CallForTenders".to_string()))]
1524    pub schema: String,
1525    ///Property: Address
1526    #[serde(skip_serializing_if = "Option::is_none")]
1527    pub address: Option<Vec<String>>,
1528    ///Property: Address
1529    #[serde(skip_serializing_if = "Option::is_none")]
1530    pub address_entity: Option<Vec<String>>,
1531    ///Property: Aleph URL
1532    #[serde(skip_serializing_if = "Option::is_none")]
1533    pub aleph_url: Option<Vec<String>>,
1534    ///Property: Alias
1535    #[serde(skip_serializing_if = "Option::is_none")]
1536    pub alias: Option<Vec<String>>,
1537    ///Property: Name of contracting authority
1538    #[serde(default)]
1539    pub authority: Vec<String>,
1540    ///Property: Contracting authority reference ID
1541    #[serde(skip_serializing_if = "Option::is_none")]
1542    pub authority_reference_id: Option<Vec<String>>,
1543    ///Property: Award Notice Date
1544    #[serde(skip_serializing_if = "Option::is_none")]
1545    pub award_notice_date: Option<Vec<String>>,
1546    ///Property: Contract awarded in Lots
1547    #[serde(skip_serializing_if = "Option::is_none")]
1548    pub awarded_in_lots: Option<Vec<String>>,
1549    ///Property: Date of awarding
1550    #[serde(skip_serializing_if = "Option::is_none")]
1551    pub awarding_date: Option<Vec<String>>,
1552    ///Property: CfT unique id
1553    #[serde(skip_serializing_if = "Option::is_none")]
1554    pub call_id: Option<Vec<String>>,
1555    ///Property: Certification check
1556    #[serde(skip_serializing_if = "Option::is_none")]
1557    pub certification_check: Option<Vec<String>>,
1558    ///Property: End of clarification period
1559    #[serde(skip_serializing_if = "Option::is_none")]
1560    pub clarification_deadline: Option<Vec<String>>,
1561    ///Property: Contract notice date
1562    #[serde(skip_serializing_if = "Option::is_none")]
1563    pub contract_notice_date: Option<Vec<String>>,
1564    ///Property: Country
1565    #[serde(skip_serializing_if = "Option::is_none")]
1566    pub country: Option<Vec<String>>,
1567    ///Property: CPV code
1568    #[serde(skip_serializing_if = "Option::is_none")]
1569    pub cpv_code: Option<Vec<String>>,
1570    ///Property: Created at
1571    #[serde(skip_serializing_if = "Option::is_none")]
1572    pub created_at: Option<Vec<String>>,
1573    ///Property: Date
1574    #[serde(skip_serializing_if = "Option::is_none")]
1575    pub date: Option<Vec<String>>,
1576    ///Property: Description
1577    #[serde(skip_serializing_if = "Option::is_none")]
1578    pub description: Option<Vec<String>>,
1579    ///Property: Directive
1580    #[serde(skip_serializing_if = "Option::is_none")]
1581    pub directive: Option<Vec<String>>,
1582    ///Property: End date
1583    #[serde(skip_serializing_if = "Option::is_none")]
1584    pub end_date: Option<Vec<String>>,
1585    ///Property: EU funding
1586    #[serde(skip_serializing_if = "Option::is_none")]
1587    pub eu_funding: Option<Vec<String>>,
1588    ///Property: Evaluation mechanism
1589    #[serde(skip_serializing_if = "Option::is_none")]
1590    pub evaluation_mechanism: Option<Vec<String>>,
1591    ///Property: Does this call fall under the scope of GPP?
1592    #[serde(skip_serializing_if = "Option::is_none")]
1593    pub falls_under_gppscope: Option<Vec<String>>,
1594    ///Property: Index text
1595    #[serde(skip_serializing_if = "Option::is_none")]
1596    pub index_text: Option<Vec<String>>,
1597    ///Property: Call for tenders result
1598    #[serde(skip_serializing_if = "Option::is_none")]
1599    pub involves_outcome: Option<Vec<String>>,
1600    ///Property: Keywords
1601    #[serde(skip_serializing_if = "Option::is_none")]
1602    pub keywords: Option<Vec<String>>,
1603    ///Property: Lots names
1604    #[serde(skip_serializing_if = "Option::is_none")]
1605    pub lots_names: Option<Vec<String>>,
1606    ///Property: Maximum number of lots
1607    #[serde(
1608        skip_serializing_if = "Option::is_none",
1609        deserialize_with = "deserialize_opt_f64_vec",
1610        default
1611    )]
1612    pub maximum_number_of_lots: Option<Vec<f64>>,
1613    ///Property: Modified on
1614    #[serde(skip_serializing_if = "Option::is_none")]
1615    pub modified_at: Option<Vec<String>>,
1616    ///Property: Multiple tenders will be accepted
1617    #[serde(skip_serializing_if = "Option::is_none")]
1618    pub multiple_tenders: Option<Vec<String>>,
1619    ///Property: Name
1620    #[serde(default)]
1621    pub name: Vec<String>,
1622    ///Property: Detected names
1623    #[serde(skip_serializing_if = "Option::is_none")]
1624    pub names_mentioned: Option<Vec<String>>,
1625    ///Property: Notes
1626    #[serde(skip_serializing_if = "Option::is_none")]
1627    pub notes: Option<Vec<String>>,
1628    ///Property: Number of lots
1629    #[serde(
1630        skip_serializing_if = "Option::is_none",
1631        deserialize_with = "deserialize_opt_f64_vec",
1632        default
1633    )]
1634    pub number_of_lots: Option<Vec<f64>>,
1635    ///Property: NUTS code
1636    #[serde(skip_serializing_if = "Option::is_none")]
1637    pub nuts_code: Option<Vec<String>>,
1638    ///Property: Published on behalf of
1639    #[serde(skip_serializing_if = "Option::is_none")]
1640    pub on_behalf_of: Option<Vec<String>>,
1641    ///Property: Payment options
1642    #[serde(skip_serializing_if = "Option::is_none")]
1643    pub payment_options: Option<Vec<String>>,
1644    ///Property: Previous name
1645    #[serde(skip_serializing_if = "Option::is_none")]
1646    pub previous_name: Option<Vec<String>>,
1647    ///Property: Procedure
1648    #[serde(skip_serializing_if = "Option::is_none")]
1649    pub procedure: Option<Vec<String>>,
1650    ///Property: Procurement type
1651    #[serde(skip_serializing_if = "Option::is_none")]
1652    pub procurement_type: Option<Vec<String>>,
1653    ///Property: Program
1654    #[serde(skip_serializing_if = "Option::is_none")]
1655    pub program: Option<Vec<String>>,
1656    ///Property: Program ID
1657    #[serde(skip_serializing_if = "Option::is_none")]
1658    pub program_id: Option<Vec<String>>,
1659    ///Property: Source document
1660    #[serde(skip_serializing_if = "Option::is_none")]
1661    pub proof: Option<Vec<String>>,
1662    ///Property: Date of publication/invitation
1663    #[serde(skip_serializing_if = "Option::is_none")]
1664    pub publication_date: Option<Vec<String>>,
1665    ///Property: Publishing source
1666    #[serde(skip_serializing_if = "Option::is_none")]
1667    pub publisher: Option<Vec<String>>,
1668    ///Property: Publishing source URL
1669    #[serde(skip_serializing_if = "Option::is_none")]
1670    pub publisher_url: Option<Vec<String>>,
1671    ///Property: Record ID
1672    #[serde(skip_serializing_if = "Option::is_none")]
1673    pub record_id: Option<Vec<String>>,
1674    ///Property: Above or below threshold
1675    #[serde(skip_serializing_if = "Option::is_none")]
1676    pub relation_to_threshold: Option<Vec<String>>,
1677    ///Property: Retrieved on
1678    #[serde(skip_serializing_if = "Option::is_none")]
1679    pub retrieved_at: Option<Vec<String>>,
1680    ///Property: Inclusion of e-Auctions
1681    #[serde(skip_serializing_if = "Option::is_none")]
1682    pub reverse_auctions_included: Option<Vec<String>>,
1683    ///Property: Source link
1684    #[serde(skip_serializing_if = "Option::is_none")]
1685    pub source_url: Option<Vec<String>>,
1686    ///Property: Start date
1687    #[serde(skip_serializing_if = "Option::is_none")]
1688    pub start_date: Option<Vec<String>>,
1689    ///Property: Submission deadline
1690    #[serde(skip_serializing_if = "Option::is_none")]
1691    pub submission_deadline: Option<Vec<String>>,
1692    ///Property: Summary
1693    #[serde(skip_serializing_if = "Option::is_none")]
1694    pub summary: Option<Vec<String>>,
1695    ///Property: TED link for published notices
1696    #[serde(skip_serializing_if = "Option::is_none")]
1697    pub ted_url: Option<Vec<String>>,
1698    ///Property: Tenderers
1699    #[serde(skip_serializing_if = "Option::is_none")]
1700    pub tenderers: Option<Vec<String>>,
1701    ///Property: Tenders for lots
1702    #[serde(skip_serializing_if = "Option::is_none")]
1703    pub tenders_for_lots: Option<Vec<String>>,
1704    ///Property: Title
1705    #[serde(default)]
1706    pub title: Vec<String>,
1707    ///Property: Topics
1708    #[serde(skip_serializing_if = "Option::is_none")]
1709    pub topics: Option<Vec<String>>,
1710    ///Property: Weak alias
1711    #[serde(skip_serializing_if = "Option::is_none")]
1712    pub weak_alias: Option<Vec<String>>,
1713    ///Property: Wikidata ID
1714    #[serde(skip_serializing_if = "Option::is_none")]
1715    pub wikidata_id: Option<Vec<String>>,
1716    ///Property: Wikipedia Article
1717    #[serde(skip_serializing_if = "Option::is_none")]
1718    pub wikipedia_url: Option<Vec<String>>,
1719}
1720impl CallForTenders {
1721    /// Create a new entity with the given ID
1722    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
1723    pub fn new(id: impl Into<String>) -> Self {
1724        Self {
1725            id: id.into(),
1726            schema: "CallForTenders".to_string(),
1727            address: None,
1728            address_entity: None,
1729            aleph_url: None,
1730            alias: None,
1731            authority: Vec::new(),
1732            authority_reference_id: None,
1733            award_notice_date: None,
1734            awarded_in_lots: None,
1735            awarding_date: None,
1736            call_id: None,
1737            certification_check: None,
1738            clarification_deadline: None,
1739            contract_notice_date: None,
1740            country: None,
1741            cpv_code: None,
1742            created_at: None,
1743            date: None,
1744            description: None,
1745            directive: None,
1746            end_date: None,
1747            eu_funding: None,
1748            evaluation_mechanism: None,
1749            falls_under_gppscope: None,
1750            index_text: None,
1751            involves_outcome: None,
1752            keywords: None,
1753            lots_names: None,
1754            maximum_number_of_lots: None,
1755            modified_at: None,
1756            multiple_tenders: None,
1757            name: Vec::new(),
1758            names_mentioned: None,
1759            notes: None,
1760            number_of_lots: None,
1761            nuts_code: None,
1762            on_behalf_of: None,
1763            payment_options: None,
1764            previous_name: None,
1765            procedure: None,
1766            procurement_type: None,
1767            program: None,
1768            program_id: None,
1769            proof: None,
1770            publication_date: None,
1771            publisher: None,
1772            publisher_url: None,
1773            record_id: None,
1774            relation_to_threshold: None,
1775            retrieved_at: None,
1776            reverse_auctions_included: None,
1777            source_url: None,
1778            start_date: None,
1779            submission_deadline: None,
1780            summary: None,
1781            ted_url: None,
1782            tenderers: None,
1783            tenders_for_lots: None,
1784            title: Vec::new(),
1785            topics: None,
1786            weak_alias: None,
1787            wikidata_id: None,
1788            wikipedia_url: None,
1789        }
1790    }
1791    /// Get the schema name
1792    pub fn schema_name() -> &'static str {
1793        "CallForTenders"
1794    }
1795}
1796///FTM Schema: Company
1797#[derive(Debug, Clone, Serialize, Deserialize)]
1798#[cfg_attr(feature = "builder", derive(Builder))]
1799#[serde(rename_all = "camelCase")]
1800pub struct Company {
1801    pub id: String,
1802    #[cfg_attr(feature = "builder", builder(default = "Company".to_string()))]
1803    pub schema: String,
1804    ///Property: Abbreviation
1805    #[serde(skip_serializing_if = "Option::is_none")]
1806    pub abbreviation: Option<Vec<String>>,
1807    ///Property: Address
1808    #[serde(skip_serializing_if = "Option::is_none")]
1809    pub address: Option<Vec<String>>,
1810    ///Property: Address
1811    #[serde(skip_serializing_if = "Option::is_none")]
1812    pub address_entity: Option<Vec<String>>,
1813    ///Property: Aleph URL
1814    #[serde(skip_serializing_if = "Option::is_none")]
1815    pub aleph_url: Option<Vec<String>>,
1816    ///Property: Alias
1817    #[serde(skip_serializing_if = "Option::is_none")]
1818    pub alias: Option<Vec<String>>,
1819    ///Property: Amount
1820    #[serde(
1821        skip_serializing_if = "Option::is_none",
1822        deserialize_with = "deserialize_opt_f64_vec",
1823        default
1824    )]
1825    pub amount: Option<Vec<f64>>,
1826    ///Property: Amount in EUR
1827    #[serde(
1828        skip_serializing_if = "Option::is_none",
1829        deserialize_with = "deserialize_opt_f64_vec",
1830        default
1831    )]
1832    pub amount_eur: Option<Vec<f64>>,
1833    ///Property: Amount in USD
1834    #[serde(
1835        skip_serializing_if = "Option::is_none",
1836        deserialize_with = "deserialize_opt_f64_vec",
1837        default
1838    )]
1839    pub amount_usd: Option<Vec<f64>>,
1840    ///Property: BIK
1841    #[serde(skip_serializing_if = "Option::is_none")]
1842    pub bik_code: Option<Vec<String>>,
1843    ///Property: BrightQuery ID
1844    #[serde(skip_serializing_if = "Option::is_none")]
1845    pub bright_query_id: Option<Vec<String>>,
1846    ///Property: BrightQuery Organization ID
1847    #[serde(skip_serializing_if = "Option::is_none")]
1848    pub bright_query_org_id: Option<Vec<String>>,
1849    ///Property: Bureau van Dijk ID
1850    #[serde(skip_serializing_if = "Option::is_none")]
1851    pub bvd_id: Option<Vec<String>>,
1852    ///Property: COD CAEM
1853    #[serde(skip_serializing_if = "Option::is_none")]
1854    pub caem_code: Option<Vec<String>>,
1855    ///Property: CAGE
1856    #[serde(skip_serializing_if = "Option::is_none")]
1857    pub cage_code: Option<Vec<String>>,
1858    ///Property: Capital
1859    #[serde(skip_serializing_if = "Option::is_none")]
1860    pub capital: Option<Vec<String>>,
1861    ///Property: SEC Central Index Key
1862    #[serde(skip_serializing_if = "Option::is_none")]
1863    pub cik_code: Option<Vec<String>>,
1864    ///Property: Classification
1865    #[serde(skip_serializing_if = "Option::is_none")]
1866    pub classification: Option<Vec<String>>,
1867    ///Property: COATO / SOATO / OKATO
1868    #[serde(skip_serializing_if = "Option::is_none")]
1869    pub coato_code: Option<Vec<String>>,
1870    ///Property: Country
1871    #[serde(skip_serializing_if = "Option::is_none")]
1872    pub country: Option<Vec<String>>,
1873    ///Property: Created at
1874    #[serde(skip_serializing_if = "Option::is_none")]
1875    pub created_at: Option<Vec<String>>,
1876    ///Property: Currency
1877    #[serde(skip_serializing_if = "Option::is_none")]
1878    pub currency: Option<Vec<String>>,
1879    ///Property: Description
1880    #[serde(skip_serializing_if = "Option::is_none")]
1881    pub description: Option<Vec<String>>,
1882    ///Property: Dissolution date
1883    #[serde(skip_serializing_if = "Option::is_none")]
1884    pub dissolution_date: Option<Vec<String>>,
1885    ///Property: DUNS
1886    #[serde(skip_serializing_if = "Option::is_none")]
1887    pub duns_code: Option<Vec<String>>,
1888    ///Property: E-Mail
1889    #[serde(skip_serializing_if = "Option::is_none")]
1890    pub email: Option<Vec<String>>,
1891    ///Property: Federal tax service code
1892    #[serde(skip_serializing_if = "Option::is_none")]
1893    pub fns_code: Option<Vec<String>>,
1894    ///Property: FSS
1895    #[serde(skip_serializing_if = "Option::is_none")]
1896    pub fss_code: Option<Vec<String>>,
1897    ///Property: GIIN
1898    #[serde(skip_serializing_if = "Option::is_none")]
1899    pub gii_number: Option<Vec<String>>,
1900    ///Property: ICIJ ID
1901    #[serde(skip_serializing_if = "Option::is_none")]
1902    pub icij_id: Option<Vec<String>>,
1903    ///Property: ID Number
1904    #[serde(skip_serializing_if = "Option::is_none")]
1905    pub id_number: Option<Vec<String>>,
1906    ///Property: IMO Number
1907    #[serde(skip_serializing_if = "Option::is_none")]
1908    pub imo_number: Option<Vec<String>>,
1909    ///Property: Incorporation date
1910    #[serde(skip_serializing_if = "Option::is_none")]
1911    pub incorporation_date: Option<Vec<String>>,
1912    ///Property: Index text
1913    #[serde(skip_serializing_if = "Option::is_none")]
1914    pub index_text: Option<Vec<String>>,
1915    ///Property: INN
1916    #[serde(skip_serializing_if = "Option::is_none")]
1917    pub inn_code: Option<Vec<String>>,
1918    ///Property: IPO
1919    #[serde(skip_serializing_if = "Option::is_none")]
1920    pub ipo_code: Option<Vec<String>>,
1921    ///Property: IRS Number
1922    #[serde(skip_serializing_if = "Option::is_none")]
1923    pub irs_code: Option<Vec<String>>,
1924    ///Property: ISIN
1925    #[serde(skip_serializing_if = "Option::is_none")]
1926    pub isin_code: Option<Vec<String>>,
1927    ///Property: JIB
1928    #[serde(skip_serializing_if = "Option::is_none")]
1929    pub jib_code: Option<Vec<String>>,
1930    ///Property: Jurisdiction
1931    #[serde(skip_serializing_if = "Option::is_none")]
1932    pub jurisdiction: Option<Vec<String>>,
1933    ///Property: Keywords
1934    #[serde(skip_serializing_if = "Option::is_none")]
1935    pub keywords: Option<Vec<String>>,
1936    ///Property: KPP
1937    #[serde(skip_serializing_if = "Option::is_none")]
1938    pub kpp_code: Option<Vec<String>>,
1939    ///Property: Legal form
1940    #[serde(skip_serializing_if = "Option::is_none")]
1941    pub legal_form: Option<Vec<String>>,
1942    ///Property: LEI
1943    #[serde(skip_serializing_if = "Option::is_none")]
1944    pub lei_code: Option<Vec<String>>,
1945    ///Property: License Number
1946    #[serde(skip_serializing_if = "Option::is_none")]
1947    pub license_number: Option<Vec<String>>,
1948    ///Property: Country of origin
1949    #[serde(skip_serializing_if = "Option::is_none")]
1950    pub main_country: Option<Vec<String>>,
1951    ///Property: MBS
1952    #[serde(skip_serializing_if = "Option::is_none")]
1953    pub mbs_code: Option<Vec<String>>,
1954    ///Property: Modified on
1955    #[serde(skip_serializing_if = "Option::is_none")]
1956    pub modified_at: Option<Vec<String>>,
1957    ///Property: Name
1958    #[serde(default)]
1959    pub name: Vec<String>,
1960    ///Property: Notes
1961    #[serde(skip_serializing_if = "Option::is_none")]
1962    pub notes: Option<Vec<String>>,
1963    ///Property: NPI
1964    #[serde(skip_serializing_if = "Option::is_none")]
1965    pub npi_code: Option<Vec<String>>,
1966    ///Property: OGRN
1967    #[serde(skip_serializing_if = "Option::is_none")]
1968    pub ogrn_code: Option<Vec<String>>,
1969    ///Property: OKOPF
1970    #[serde(skip_serializing_if = "Option::is_none")]
1971    pub okopf_code: Option<Vec<String>>,
1972    ///Property: OKPO
1973    #[serde(skip_serializing_if = "Option::is_none")]
1974    pub okpo_code: Option<Vec<String>>,
1975    ///Property: OKSM
1976    #[serde(skip_serializing_if = "Option::is_none")]
1977    pub oksm_code: Option<Vec<String>>,
1978    ///Property: OKVED(2) Classifier
1979    #[serde(skip_serializing_if = "Option::is_none")]
1980    pub okved_code: Option<Vec<String>>,
1981    ///Property: OpenCorporates URL
1982    #[serde(skip_serializing_if = "Option::is_none")]
1983    pub opencorporates_url: Option<Vec<String>>,
1984    ///Property: Parent company
1985    #[serde(skip_serializing_if = "Option::is_none")]
1986    pub parent: Option<Vec<String>>,
1987    ///Property: PermID
1988    #[serde(skip_serializing_if = "Option::is_none")]
1989    pub perm_id: Option<Vec<String>>,
1990    ///Property: PFR Number
1991    #[serde(skip_serializing_if = "Option::is_none")]
1992    pub pfr_number: Option<Vec<String>>,
1993    ///Property: Phone
1994    #[serde(skip_serializing_if = "Option::is_none")]
1995    pub phone: Option<Vec<String>>,
1996    ///Property: Previous name
1997    #[serde(skip_serializing_if = "Option::is_none")]
1998    pub previous_name: Option<Vec<String>>,
1999    ///Property: Program
2000    #[serde(skip_serializing_if = "Option::is_none")]
2001    pub program: Option<Vec<String>>,
2002    ///Property: Program ID
2003    #[serde(skip_serializing_if = "Option::is_none")]
2004    pub program_id: Option<Vec<String>>,
2005    ///Property: Source document
2006    #[serde(skip_serializing_if = "Option::is_none")]
2007    pub proof: Option<Vec<String>>,
2008    ///Property: Publishing source
2009    #[serde(skip_serializing_if = "Option::is_none")]
2010    pub publisher: Option<Vec<String>>,
2011    ///Property: Publishing source URL
2012    #[serde(skip_serializing_if = "Option::is_none")]
2013    pub publisher_url: Option<Vec<String>>,
2014    ///Property: Registration number
2015    #[serde(skip_serializing_if = "Option::is_none")]
2016    pub registration_number: Option<Vec<String>>,
2017    ///Property: Retrieved on
2018    #[serde(skip_serializing_if = "Option::is_none")]
2019    pub retrieved_at: Option<Vec<String>>,
2020    ///Property: Reuters Instrument Code
2021    #[serde(skip_serializing_if = "Option::is_none")]
2022    pub ric_code: Option<Vec<String>>,
2023    ///Property: Sayari Entity ID
2024    #[serde(skip_serializing_if = "Option::is_none")]
2025    pub sayari_id: Option<Vec<String>>,
2026    ///Property: Sector
2027    #[serde(skip_serializing_if = "Option::is_none")]
2028    pub sector: Option<Vec<String>>,
2029    ///Property: Source link
2030    #[serde(skip_serializing_if = "Option::is_none")]
2031    pub source_url: Option<Vec<String>>,
2032    ///Property: Status
2033    #[serde(skip_serializing_if = "Option::is_none")]
2034    pub status: Option<Vec<String>>,
2035    ///Property: Summary
2036    #[serde(skip_serializing_if = "Option::is_none")]
2037    pub summary: Option<Vec<String>>,
2038    ///Property: SWIFT/BIC
2039    #[serde(skip_serializing_if = "Option::is_none")]
2040    pub swift_bic: Option<Vec<String>>,
2041    ///Property: Tax Number
2042    #[serde(skip_serializing_if = "Option::is_none")]
2043    pub tax_number: Option<Vec<String>>,
2044    ///Property: Tax status
2045    #[serde(skip_serializing_if = "Option::is_none")]
2046    pub tax_status: Option<Vec<String>>,
2047    ///Property: Stock ticker symbol
2048    #[serde(skip_serializing_if = "Option::is_none")]
2049    pub ticker: Option<Vec<String>>,
2050    ///Property: Topics
2051    #[serde(skip_serializing_if = "Option::is_none")]
2052    pub topics: Option<Vec<String>>,
2053    ///Property: Unique Entity ID
2054    #[serde(skip_serializing_if = "Option::is_none")]
2055    pub unique_entity_id: Option<Vec<String>>,
2056    ///Property: USCC
2057    #[serde(skip_serializing_if = "Option::is_none")]
2058    pub usc_code: Option<Vec<String>>,
2059    ///Property: V.A.T. Identifier
2060    #[serde(skip_serializing_if = "Option::is_none")]
2061    pub vat_code: Option<Vec<String>>,
2062    ///Property: VOEN
2063    #[serde(skip_serializing_if = "Option::is_none")]
2064    pub voen_code: Option<Vec<String>>,
2065    ///Property: Weak alias
2066    #[serde(skip_serializing_if = "Option::is_none")]
2067    pub weak_alias: Option<Vec<String>>,
2068    ///Property: Website
2069    #[serde(skip_serializing_if = "Option::is_none")]
2070    pub website: Option<Vec<String>>,
2071    ///Property: Wikidata ID
2072    #[serde(skip_serializing_if = "Option::is_none")]
2073    pub wikidata_id: Option<Vec<String>>,
2074    ///Property: Wikipedia Article
2075    #[serde(skip_serializing_if = "Option::is_none")]
2076    pub wikipedia_url: Option<Vec<String>>,
2077}
2078impl Company {
2079    /// Create a new entity with the given ID
2080    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
2081    pub fn new(id: impl Into<String>) -> Self {
2082        Self {
2083            id: id.into(),
2084            schema: "Company".to_string(),
2085            abbreviation: None,
2086            address: None,
2087            address_entity: None,
2088            aleph_url: None,
2089            alias: None,
2090            amount: None,
2091            amount_eur: None,
2092            amount_usd: None,
2093            bik_code: None,
2094            bright_query_id: None,
2095            bright_query_org_id: None,
2096            bvd_id: None,
2097            caem_code: None,
2098            cage_code: None,
2099            capital: None,
2100            cik_code: None,
2101            classification: None,
2102            coato_code: None,
2103            country: None,
2104            created_at: None,
2105            currency: None,
2106            description: None,
2107            dissolution_date: None,
2108            duns_code: None,
2109            email: None,
2110            fns_code: None,
2111            fss_code: None,
2112            gii_number: None,
2113            icij_id: None,
2114            id_number: None,
2115            imo_number: None,
2116            incorporation_date: None,
2117            index_text: None,
2118            inn_code: None,
2119            ipo_code: None,
2120            irs_code: None,
2121            isin_code: None,
2122            jib_code: None,
2123            jurisdiction: None,
2124            keywords: None,
2125            kpp_code: None,
2126            legal_form: None,
2127            lei_code: None,
2128            license_number: None,
2129            main_country: None,
2130            mbs_code: None,
2131            modified_at: None,
2132            name: Vec::new(),
2133            notes: None,
2134            npi_code: None,
2135            ogrn_code: None,
2136            okopf_code: None,
2137            okpo_code: None,
2138            oksm_code: None,
2139            okved_code: None,
2140            opencorporates_url: None,
2141            parent: None,
2142            perm_id: None,
2143            pfr_number: None,
2144            phone: None,
2145            previous_name: None,
2146            program: None,
2147            program_id: None,
2148            proof: None,
2149            publisher: None,
2150            publisher_url: None,
2151            registration_number: None,
2152            retrieved_at: None,
2153            ric_code: None,
2154            sayari_id: None,
2155            sector: None,
2156            source_url: None,
2157            status: None,
2158            summary: None,
2159            swift_bic: None,
2160            tax_number: None,
2161            tax_status: None,
2162            ticker: None,
2163            topics: None,
2164            unique_entity_id: None,
2165            usc_code: None,
2166            vat_code: None,
2167            voen_code: None,
2168            weak_alias: None,
2169            website: None,
2170            wikidata_id: None,
2171            wikipedia_url: None,
2172        }
2173    }
2174    /// Get the schema name
2175    pub fn schema_name() -> &'static str {
2176        "Company"
2177    }
2178}
2179///FTM Schema: Contract
2180#[derive(Debug, Clone, Serialize, Deserialize)]
2181#[cfg_attr(feature = "builder", derive(Builder))]
2182#[serde(rename_all = "camelCase")]
2183pub struct Contract {
2184    pub id: String,
2185    #[cfg_attr(feature = "builder", builder(default = "Contract".to_string()))]
2186    pub schema: String,
2187    ///Property: Address
2188    #[serde(skip_serializing_if = "Option::is_none")]
2189    pub address: Option<Vec<String>>,
2190    ///Property: Address
2191    #[serde(skip_serializing_if = "Option::is_none")]
2192    pub address_entity: Option<Vec<String>>,
2193    ///Property: Aleph URL
2194    #[serde(skip_serializing_if = "Option::is_none")]
2195    pub aleph_url: Option<Vec<String>>,
2196    ///Property: Alias
2197    #[serde(skip_serializing_if = "Option::is_none")]
2198    pub alias: Option<Vec<String>>,
2199    ///Property: Amount
2200    #[serde(
2201        skip_serializing_if = "Option::is_none",
2202        deserialize_with = "deserialize_opt_f64_vec",
2203        default
2204    )]
2205    pub amount: Option<Vec<f64>>,
2206    ///Property: Amount in EUR
2207    #[serde(
2208        skip_serializing_if = "Option::is_none",
2209        deserialize_with = "deserialize_opt_f64_vec",
2210        default
2211    )]
2212    pub amount_eur: Option<Vec<f64>>,
2213    ///Property: Amount in USD
2214    #[serde(
2215        skip_serializing_if = "Option::is_none",
2216        deserialize_with = "deserialize_opt_f64_vec",
2217        default
2218    )]
2219    pub amount_usd: Option<Vec<f64>>,
2220    ///Property: Contract authority
2221    #[serde(skip_serializing_if = "Option::is_none")]
2222    pub authority: Option<Vec<String>>,
2223    ///Property: Cancelled?
2224    #[serde(skip_serializing_if = "Option::is_none")]
2225    pub cancelled: Option<Vec<String>>,
2226    ///Property: Classification
2227    #[serde(skip_serializing_if = "Option::is_none")]
2228    pub classification: Option<Vec<String>>,
2229    ///Property: Contract date
2230    #[serde(skip_serializing_if = "Option::is_none")]
2231    pub contract_date: Option<Vec<String>>,
2232    ///Property: Country
2233    #[serde(skip_serializing_if = "Option::is_none")]
2234    pub country: Option<Vec<String>>,
2235    ///Property: Created at
2236    #[serde(skip_serializing_if = "Option::is_none")]
2237    pub created_at: Option<Vec<String>>,
2238    ///Property: Contract award criteria
2239    #[serde(skip_serializing_if = "Option::is_none")]
2240    pub criteria: Option<Vec<String>>,
2241    ///Property: Currency
2242    #[serde(skip_serializing_if = "Option::is_none")]
2243    pub currency: Option<Vec<String>>,
2244    ///Property: Description
2245    #[serde(skip_serializing_if = "Option::is_none")]
2246    pub description: Option<Vec<String>>,
2247    ///Property: Index text
2248    #[serde(skip_serializing_if = "Option::is_none")]
2249    pub index_text: Option<Vec<String>>,
2250    ///Property: Keywords
2251    #[serde(skip_serializing_if = "Option::is_none")]
2252    pub keywords: Option<Vec<String>>,
2253    ///Property: Language
2254    #[serde(skip_serializing_if = "Option::is_none")]
2255    pub language: Option<Vec<String>>,
2256    ///Property: Procurement method
2257    #[serde(skip_serializing_if = "Option::is_none")]
2258    pub method: Option<Vec<String>>,
2259    ///Property: Modified on
2260    #[serde(skip_serializing_if = "Option::is_none")]
2261    pub modified_at: Option<Vec<String>>,
2262    ///Property: Name
2263    #[serde(default)]
2264    pub name: Vec<String>,
2265    ///Property: Notes
2266    #[serde(skip_serializing_if = "Option::is_none")]
2267    pub notes: Option<Vec<String>>,
2268    ///Property: Contract Award Notice ID
2269    #[serde(skip_serializing_if = "Option::is_none")]
2270    pub notice_id: Option<Vec<String>>,
2271    ///Property: Number of awards
2272    #[serde(skip_serializing_if = "Option::is_none")]
2273    pub number_awards: Option<Vec<String>>,
2274    ///Property: Previous name
2275    #[serde(skip_serializing_if = "Option::is_none")]
2276    pub previous_name: Option<Vec<String>>,
2277    ///Property: Contract procedure
2278    #[serde(skip_serializing_if = "Option::is_none")]
2279    pub procedure: Option<Vec<String>>,
2280    ///Property: Procedure number
2281    #[serde(skip_serializing_if = "Option::is_none")]
2282    pub procedure_number: Option<Vec<String>>,
2283    ///Property: Program
2284    #[serde(skip_serializing_if = "Option::is_none")]
2285    pub program: Option<Vec<String>>,
2286    ///Property: Program ID
2287    #[serde(skip_serializing_if = "Option::is_none")]
2288    pub program_id: Option<Vec<String>>,
2289    ///Property: Project
2290    #[serde(skip_serializing_if = "Option::is_none")]
2291    pub project: Option<Vec<String>>,
2292    ///Property: Source document
2293    #[serde(skip_serializing_if = "Option::is_none")]
2294    pub proof: Option<Vec<String>>,
2295    ///Property: Publishing source
2296    #[serde(skip_serializing_if = "Option::is_none")]
2297    pub publisher: Option<Vec<String>>,
2298    ///Property: Publishing source URL
2299    #[serde(skip_serializing_if = "Option::is_none")]
2300    pub publisher_url: Option<Vec<String>>,
2301    ///Property: Retrieved on
2302    #[serde(skip_serializing_if = "Option::is_none")]
2303    pub retrieved_at: Option<Vec<String>>,
2304    ///Property: Source link
2305    #[serde(skip_serializing_if = "Option::is_none")]
2306    pub source_url: Option<Vec<String>>,
2307    ///Property: Status
2308    #[serde(skip_serializing_if = "Option::is_none")]
2309    pub status: Option<Vec<String>>,
2310    ///Property: Summary
2311    #[serde(skip_serializing_if = "Option::is_none")]
2312    pub summary: Option<Vec<String>>,
2313    ///Property: Title
2314    #[serde(default)]
2315    pub title: Vec<String>,
2316    ///Property: Topics
2317    #[serde(skip_serializing_if = "Option::is_none")]
2318    pub topics: Option<Vec<String>>,
2319    ///Property: Type
2320    #[serde(skip_serializing_if = "Option::is_none")]
2321    pub type_: Option<Vec<String>>,
2322    ///Property: Weak alias
2323    #[serde(skip_serializing_if = "Option::is_none")]
2324    pub weak_alias: Option<Vec<String>>,
2325    ///Property: Wikidata ID
2326    #[serde(skip_serializing_if = "Option::is_none")]
2327    pub wikidata_id: Option<Vec<String>>,
2328    ///Property: Wikipedia Article
2329    #[serde(skip_serializing_if = "Option::is_none")]
2330    pub wikipedia_url: Option<Vec<String>>,
2331}
2332impl Contract {
2333    /// Create a new entity with the given ID
2334    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
2335    pub fn new(id: impl Into<String>) -> Self {
2336        Self {
2337            id: id.into(),
2338            schema: "Contract".to_string(),
2339            address: None,
2340            address_entity: None,
2341            aleph_url: None,
2342            alias: None,
2343            amount: None,
2344            amount_eur: None,
2345            amount_usd: None,
2346            authority: None,
2347            cancelled: None,
2348            classification: None,
2349            contract_date: None,
2350            country: None,
2351            created_at: None,
2352            criteria: None,
2353            currency: None,
2354            description: None,
2355            index_text: None,
2356            keywords: None,
2357            language: None,
2358            method: None,
2359            modified_at: None,
2360            name: Vec::new(),
2361            notes: None,
2362            notice_id: None,
2363            number_awards: None,
2364            previous_name: None,
2365            procedure: None,
2366            procedure_number: None,
2367            program: None,
2368            program_id: None,
2369            project: None,
2370            proof: None,
2371            publisher: None,
2372            publisher_url: None,
2373            retrieved_at: None,
2374            source_url: None,
2375            status: None,
2376            summary: None,
2377            title: Vec::new(),
2378            topics: None,
2379            type_: None,
2380            weak_alias: None,
2381            wikidata_id: None,
2382            wikipedia_url: None,
2383        }
2384    }
2385    /// Get the schema name
2386    pub fn schema_name() -> &'static str {
2387        "Contract"
2388    }
2389}
2390///FTM Schema: Contract award
2391#[derive(Debug, Clone, Serialize, Deserialize)]
2392#[cfg_attr(feature = "builder", derive(Builder))]
2393#[serde(rename_all = "camelCase")]
2394pub struct ContractAward {
2395    pub id: String,
2396    #[cfg_attr(feature = "builder", builder(default = "ContractAward".to_string()))]
2397    pub schema: String,
2398    ///Property: Aleph URL
2399    #[serde(skip_serializing_if = "Option::is_none")]
2400    pub aleph_url: Option<Vec<String>>,
2401    ///Property: Amended
2402    #[serde(skip_serializing_if = "Option::is_none")]
2403    pub amended: Option<Vec<String>>,
2404    ///Property: Amount
2405    #[serde(
2406        skip_serializing_if = "Option::is_none",
2407        deserialize_with = "deserialize_opt_f64_vec",
2408        default
2409    )]
2410    pub amount: Option<Vec<f64>>,
2411    ///Property: Amount in EUR
2412    #[serde(
2413        skip_serializing_if = "Option::is_none",
2414        deserialize_with = "deserialize_opt_f64_vec",
2415        default
2416    )]
2417    pub amount_eur: Option<Vec<f64>>,
2418    ///Property: Amount in USD
2419    #[serde(
2420        skip_serializing_if = "Option::is_none",
2421        deserialize_with = "deserialize_opt_f64_vec",
2422        default
2423    )]
2424    pub amount_usd: Option<Vec<f64>>,
2425    ///Property: Call For Tenders
2426    #[serde(skip_serializing_if = "Option::is_none")]
2427    pub call_for_tenders: Option<Vec<String>>,
2428    ///Property: Contract
2429    #[serde(default)]
2430    pub contract: Vec<String>,
2431    ///Property: CPV code
2432    #[serde(skip_serializing_if = "Option::is_none")]
2433    pub cpv_code: Option<Vec<String>>,
2434    ///Property: Currency
2435    #[serde(skip_serializing_if = "Option::is_none")]
2436    pub currency: Option<Vec<String>>,
2437    ///Property: Date
2438    #[serde(skip_serializing_if = "Option::is_none")]
2439    pub date: Option<Vec<String>>,
2440    ///Property: Decision reason
2441    #[serde(skip_serializing_if = "Option::is_none")]
2442    pub decision_reason: Option<Vec<String>>,
2443    ///Property: Description
2444    #[serde(skip_serializing_if = "Option::is_none")]
2445    pub description: Option<Vec<String>>,
2446    ///Property: Document number
2447    #[serde(skip_serializing_if = "Option::is_none")]
2448    pub document_number: Option<Vec<String>>,
2449    ///Property: Document type
2450    #[serde(skip_serializing_if = "Option::is_none")]
2451    pub document_type: Option<Vec<String>>,
2452    ///Property: End date
2453    #[serde(skip_serializing_if = "Option::is_none")]
2454    pub end_date: Option<Vec<String>>,
2455    ///Property: Index text
2456    #[serde(skip_serializing_if = "Option::is_none")]
2457    pub index_text: Option<Vec<String>>,
2458    ///Property: Lot number
2459    #[serde(skip_serializing_if = "Option::is_none")]
2460    pub lot_number: Option<Vec<String>>,
2461    ///Property: Modified on
2462    #[serde(skip_serializing_if = "Option::is_none")]
2463    pub modified_at: Option<Vec<String>>,
2464    ///Property: Detected names
2465    #[serde(skip_serializing_if = "Option::is_none")]
2466    pub names_mentioned: Option<Vec<String>>,
2467    ///Property: NUTS code
2468    #[serde(skip_serializing_if = "Option::is_none")]
2469    pub nuts_code: Option<Vec<String>>,
2470    ///Property: Source document
2471    #[serde(skip_serializing_if = "Option::is_none")]
2472    pub proof: Option<Vec<String>>,
2473    ///Property: Publishing source
2474    #[serde(skip_serializing_if = "Option::is_none")]
2475    pub publisher: Option<Vec<String>>,
2476    ///Property: Publishing source URL
2477    #[serde(skip_serializing_if = "Option::is_none")]
2478    pub publisher_url: Option<Vec<String>>,
2479    ///Property: Record ID
2480    #[serde(skip_serializing_if = "Option::is_none")]
2481    pub record_id: Option<Vec<String>>,
2482    ///Property: Retrieved on
2483    #[serde(skip_serializing_if = "Option::is_none")]
2484    pub retrieved_at: Option<Vec<String>>,
2485    ///Property: Role
2486    #[serde(skip_serializing_if = "Option::is_none")]
2487    pub role: Option<Vec<String>>,
2488    ///Property: Source link
2489    #[serde(skip_serializing_if = "Option::is_none")]
2490    pub source_url: Option<Vec<String>>,
2491    ///Property: Start date
2492    #[serde(skip_serializing_if = "Option::is_none")]
2493    pub start_date: Option<Vec<String>>,
2494    ///Property: Status
2495    #[serde(skip_serializing_if = "Option::is_none")]
2496    pub status: Option<Vec<String>>,
2497    ///Property: Summary
2498    #[serde(skip_serializing_if = "Option::is_none")]
2499    pub summary: Option<Vec<String>>,
2500    ///Property: Supplier
2501    #[serde(default)]
2502    pub supplier: Vec<String>,
2503}
2504impl ContractAward {
2505    /// Create a new entity with the given ID
2506    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
2507    pub fn new(id: impl Into<String>) -> Self {
2508        Self {
2509            id: id.into(),
2510            schema: "ContractAward".to_string(),
2511            aleph_url: None,
2512            amended: None,
2513            amount: None,
2514            amount_eur: None,
2515            amount_usd: None,
2516            call_for_tenders: None,
2517            contract: Vec::new(),
2518            cpv_code: None,
2519            currency: None,
2520            date: None,
2521            decision_reason: None,
2522            description: None,
2523            document_number: None,
2524            document_type: None,
2525            end_date: None,
2526            index_text: None,
2527            lot_number: None,
2528            modified_at: None,
2529            names_mentioned: None,
2530            nuts_code: None,
2531            proof: None,
2532            publisher: None,
2533            publisher_url: None,
2534            record_id: None,
2535            retrieved_at: None,
2536            role: None,
2537            source_url: None,
2538            start_date: None,
2539            status: None,
2540            summary: None,
2541            supplier: Vec::new(),
2542        }
2543    }
2544    /// Get the schema name
2545    pub fn schema_name() -> &'static str {
2546        "ContractAward"
2547    }
2548}
2549///FTM Schema: Court case
2550#[derive(Debug, Clone, Serialize, Deserialize)]
2551#[cfg_attr(feature = "builder", derive(Builder))]
2552#[serde(rename_all = "camelCase")]
2553pub struct CourtCase {
2554    pub id: String,
2555    #[cfg_attr(feature = "builder", builder(default = "CourtCase".to_string()))]
2556    pub schema: String,
2557    ///Property: Address
2558    #[serde(skip_serializing_if = "Option::is_none")]
2559    pub address: Option<Vec<String>>,
2560    ///Property: Address
2561    #[serde(skip_serializing_if = "Option::is_none")]
2562    pub address_entity: Option<Vec<String>>,
2563    ///Property: Aleph URL
2564    #[serde(skip_serializing_if = "Option::is_none")]
2565    pub aleph_url: Option<Vec<String>>,
2566    ///Property: Alias
2567    #[serde(skip_serializing_if = "Option::is_none")]
2568    pub alias: Option<Vec<String>>,
2569    ///Property: Case number
2570    #[serde(skip_serializing_if = "Option::is_none")]
2571    pub case_number: Option<Vec<String>>,
2572    ///Property: Category
2573    #[serde(skip_serializing_if = "Option::is_none")]
2574    pub category: Option<Vec<String>>,
2575    ///Property: Close date
2576    #[serde(skip_serializing_if = "Option::is_none")]
2577    pub close_date: Option<Vec<String>>,
2578    ///Property: Country
2579    #[serde(skip_serializing_if = "Option::is_none")]
2580    pub country: Option<Vec<String>>,
2581    ///Property: Court
2582    #[serde(skip_serializing_if = "Option::is_none")]
2583    pub court: Option<Vec<String>>,
2584    ///Property: Created at
2585    #[serde(skip_serializing_if = "Option::is_none")]
2586    pub created_at: Option<Vec<String>>,
2587    ///Property: Description
2588    #[serde(skip_serializing_if = "Option::is_none")]
2589    pub description: Option<Vec<String>>,
2590    ///Property: File date
2591    #[serde(skip_serializing_if = "Option::is_none")]
2592    pub file_date: Option<Vec<String>>,
2593    ///Property: Index text
2594    #[serde(skip_serializing_if = "Option::is_none")]
2595    pub index_text: Option<Vec<String>>,
2596    ///Property: Keywords
2597    #[serde(skip_serializing_if = "Option::is_none")]
2598    pub keywords: Option<Vec<String>>,
2599    ///Property: Modified on
2600    #[serde(skip_serializing_if = "Option::is_none")]
2601    pub modified_at: Option<Vec<String>>,
2602    ///Property: Name
2603    #[serde(default)]
2604    pub name: Vec<String>,
2605    ///Property: Notes
2606    #[serde(skip_serializing_if = "Option::is_none")]
2607    pub notes: Option<Vec<String>>,
2608    ///Property: Previous name
2609    #[serde(skip_serializing_if = "Option::is_none")]
2610    pub previous_name: Option<Vec<String>>,
2611    ///Property: Program
2612    #[serde(skip_serializing_if = "Option::is_none")]
2613    pub program: Option<Vec<String>>,
2614    ///Property: Program ID
2615    #[serde(skip_serializing_if = "Option::is_none")]
2616    pub program_id: Option<Vec<String>>,
2617    ///Property: Source document
2618    #[serde(skip_serializing_if = "Option::is_none")]
2619    pub proof: Option<Vec<String>>,
2620    ///Property: Publishing source
2621    #[serde(skip_serializing_if = "Option::is_none")]
2622    pub publisher: Option<Vec<String>>,
2623    ///Property: Publishing source URL
2624    #[serde(skip_serializing_if = "Option::is_none")]
2625    pub publisher_url: Option<Vec<String>>,
2626    ///Property: Retrieved on
2627    #[serde(skip_serializing_if = "Option::is_none")]
2628    pub retrieved_at: Option<Vec<String>>,
2629    ///Property: Source link
2630    #[serde(skip_serializing_if = "Option::is_none")]
2631    pub source_url: Option<Vec<String>>,
2632    ///Property: Status
2633    #[serde(skip_serializing_if = "Option::is_none")]
2634    pub status: Option<Vec<String>>,
2635    ///Property: Summary
2636    #[serde(skip_serializing_if = "Option::is_none")]
2637    pub summary: Option<Vec<String>>,
2638    ///Property: Topics
2639    #[serde(skip_serializing_if = "Option::is_none")]
2640    pub topics: Option<Vec<String>>,
2641    ///Property: Type
2642    #[serde(skip_serializing_if = "Option::is_none")]
2643    pub type_: Option<Vec<String>>,
2644    ///Property: Weak alias
2645    #[serde(skip_serializing_if = "Option::is_none")]
2646    pub weak_alias: Option<Vec<String>>,
2647    ///Property: Wikidata ID
2648    #[serde(skip_serializing_if = "Option::is_none")]
2649    pub wikidata_id: Option<Vec<String>>,
2650    ///Property: Wikipedia Article
2651    #[serde(skip_serializing_if = "Option::is_none")]
2652    pub wikipedia_url: Option<Vec<String>>,
2653}
2654impl CourtCase {
2655    /// Create a new entity with the given ID
2656    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
2657    pub fn new(id: impl Into<String>) -> Self {
2658        Self {
2659            id: id.into(),
2660            schema: "CourtCase".to_string(),
2661            address: None,
2662            address_entity: None,
2663            aleph_url: None,
2664            alias: None,
2665            case_number: None,
2666            category: None,
2667            close_date: None,
2668            country: None,
2669            court: None,
2670            created_at: None,
2671            description: None,
2672            file_date: None,
2673            index_text: None,
2674            keywords: None,
2675            modified_at: None,
2676            name: Vec::new(),
2677            notes: None,
2678            previous_name: None,
2679            program: None,
2680            program_id: None,
2681            proof: None,
2682            publisher: None,
2683            publisher_url: None,
2684            retrieved_at: None,
2685            source_url: None,
2686            status: None,
2687            summary: None,
2688            topics: None,
2689            type_: None,
2690            weak_alias: None,
2691            wikidata_id: None,
2692            wikipedia_url: None,
2693        }
2694    }
2695    /// Get the schema name
2696    pub fn schema_name() -> &'static str {
2697        "CourtCase"
2698    }
2699}
2700///FTM Schema: Case party
2701#[derive(Debug, Clone, Serialize, Deserialize)]
2702#[cfg_attr(feature = "builder", derive(Builder))]
2703#[serde(rename_all = "camelCase")]
2704pub struct CourtCaseParty {
2705    pub id: String,
2706    #[cfg_attr(feature = "builder", builder(default = "CourtCaseParty".to_string()))]
2707    pub schema: String,
2708    ///Property: Aleph URL
2709    #[serde(skip_serializing_if = "Option::is_none")]
2710    pub aleph_url: Option<Vec<String>>,
2711    ///Property: Case
2712    #[serde(default)]
2713    pub case: Vec<String>,
2714    ///Property: Date
2715    #[serde(skip_serializing_if = "Option::is_none")]
2716    pub date: Option<Vec<String>>,
2717    ///Property: Description
2718    #[serde(skip_serializing_if = "Option::is_none")]
2719    pub description: Option<Vec<String>>,
2720    ///Property: End date
2721    #[serde(skip_serializing_if = "Option::is_none")]
2722    pub end_date: Option<Vec<String>>,
2723    ///Property: Index text
2724    #[serde(skip_serializing_if = "Option::is_none")]
2725    pub index_text: Option<Vec<String>>,
2726    ///Property: Modified on
2727    #[serde(skip_serializing_if = "Option::is_none")]
2728    pub modified_at: Option<Vec<String>>,
2729    ///Property: Detected names
2730    #[serde(skip_serializing_if = "Option::is_none")]
2731    pub names_mentioned: Option<Vec<String>>,
2732    ///Property: Party
2733    #[serde(default)]
2734    pub party: Vec<String>,
2735    ///Property: Source document
2736    #[serde(skip_serializing_if = "Option::is_none")]
2737    pub proof: Option<Vec<String>>,
2738    ///Property: Publishing source
2739    #[serde(skip_serializing_if = "Option::is_none")]
2740    pub publisher: Option<Vec<String>>,
2741    ///Property: Publishing source URL
2742    #[serde(skip_serializing_if = "Option::is_none")]
2743    pub publisher_url: Option<Vec<String>>,
2744    ///Property: Record ID
2745    #[serde(skip_serializing_if = "Option::is_none")]
2746    pub record_id: Option<Vec<String>>,
2747    ///Property: Retrieved on
2748    #[serde(skip_serializing_if = "Option::is_none")]
2749    pub retrieved_at: Option<Vec<String>>,
2750    ///Property: Role
2751    #[serde(skip_serializing_if = "Option::is_none")]
2752    pub role: Option<Vec<String>>,
2753    ///Property: Source link
2754    #[serde(skip_serializing_if = "Option::is_none")]
2755    pub source_url: Option<Vec<String>>,
2756    ///Property: Start date
2757    #[serde(skip_serializing_if = "Option::is_none")]
2758    pub start_date: Option<Vec<String>>,
2759    ///Property: Status
2760    #[serde(skip_serializing_if = "Option::is_none")]
2761    pub status: Option<Vec<String>>,
2762    ///Property: Summary
2763    #[serde(skip_serializing_if = "Option::is_none")]
2764    pub summary: Option<Vec<String>>,
2765}
2766impl CourtCaseParty {
2767    /// Create a new entity with the given ID
2768    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
2769    pub fn new(id: impl Into<String>) -> Self {
2770        Self {
2771            id: id.into(),
2772            schema: "CourtCaseParty".to_string(),
2773            aleph_url: None,
2774            case: Vec::new(),
2775            date: None,
2776            description: None,
2777            end_date: None,
2778            index_text: None,
2779            modified_at: None,
2780            names_mentioned: None,
2781            party: Vec::new(),
2782            proof: None,
2783            publisher: None,
2784            publisher_url: None,
2785            record_id: None,
2786            retrieved_at: None,
2787            role: None,
2788            source_url: None,
2789            start_date: None,
2790            status: None,
2791            summary: None,
2792        }
2793    }
2794    /// Get the schema name
2795    pub fn schema_name() -> &'static str {
2796        "CourtCaseParty"
2797    }
2798}
2799///FTM Schema: Cryptocurrency wallet
2800#[derive(Debug, Clone, Serialize, Deserialize)]
2801#[cfg_attr(feature = "builder", derive(Builder))]
2802#[serde(rename_all = "camelCase")]
2803pub struct CryptoWallet {
2804    pub id: String,
2805    #[cfg_attr(feature = "builder", builder(default = "CryptoWallet".to_string()))]
2806    pub schema: String,
2807    ///Property: Account ID
2808    #[serde(skip_serializing_if = "Option::is_none")]
2809    pub account_id: Option<Vec<String>>,
2810    ///Property: Address
2811    #[serde(skip_serializing_if = "Option::is_none")]
2812    pub address: Option<Vec<String>>,
2813    ///Property: Address
2814    #[serde(skip_serializing_if = "Option::is_none")]
2815    pub address_entity: Option<Vec<String>>,
2816    ///Property: Aleph URL
2817    #[serde(skip_serializing_if = "Option::is_none")]
2818    pub aleph_url: Option<Vec<String>>,
2819    ///Property: Alias
2820    #[serde(skip_serializing_if = "Option::is_none")]
2821    pub alias: Option<Vec<String>>,
2822    ///Property: Amount
2823    #[serde(
2824        skip_serializing_if = "Option::is_none",
2825        deserialize_with = "deserialize_opt_f64_vec",
2826        default
2827    )]
2828    pub amount: Option<Vec<f64>>,
2829    ///Property: Amount in EUR
2830    #[serde(
2831        skip_serializing_if = "Option::is_none",
2832        deserialize_with = "deserialize_opt_f64_vec",
2833        default
2834    )]
2835    pub amount_eur: Option<Vec<f64>>,
2836    ///Property: Amount in USD
2837    #[serde(
2838        skip_serializing_if = "Option::is_none",
2839        deserialize_with = "deserialize_opt_f64_vec",
2840        default
2841    )]
2842    pub amount_usd: Option<Vec<f64>>,
2843    ///Property: Balance
2844    #[serde(
2845        skip_serializing_if = "Option::is_none",
2846        deserialize_with = "deserialize_opt_f64_vec",
2847        default
2848    )]
2849    pub balance: Option<Vec<f64>>,
2850    ///Property: Balance date
2851    #[serde(skip_serializing_if = "Option::is_none")]
2852    pub balance_date: Option<Vec<String>>,
2853    ///Property: Country
2854    #[serde(skip_serializing_if = "Option::is_none")]
2855    pub country: Option<Vec<String>>,
2856    ///Property: Created at
2857    #[serde(skip_serializing_if = "Option::is_none")]
2858    pub created_at: Option<Vec<String>>,
2859    ///Property: Creation date
2860    #[serde(skip_serializing_if = "Option::is_none")]
2861    pub creation_date: Option<Vec<String>>,
2862    ///Property: Currency
2863    #[serde(skip_serializing_if = "Option::is_none")]
2864    pub currency: Option<Vec<String>>,
2865    ///Property: Currency short code
2866    #[serde(skip_serializing_if = "Option::is_none")]
2867    pub currency_symbol: Option<Vec<String>>,
2868    ///Property: Description
2869    #[serde(skip_serializing_if = "Option::is_none")]
2870    pub description: Option<Vec<String>>,
2871    ///Property: Wallet holder
2872    #[serde(skip_serializing_if = "Option::is_none")]
2873    pub holder: Option<Vec<String>>,
2874    ///Property: Index text
2875    #[serde(skip_serializing_if = "Option::is_none")]
2876    pub index_text: Option<Vec<String>>,
2877    ///Property: Keywords
2878    #[serde(skip_serializing_if = "Option::is_none")]
2879    pub keywords: Option<Vec<String>>,
2880    ///Property: Managing exchange
2881    #[serde(skip_serializing_if = "Option::is_none")]
2882    pub managing_exchange: Option<Vec<String>>,
2883    ///Property: Modified on
2884    #[serde(skip_serializing_if = "Option::is_none")]
2885    pub modified_at: Option<Vec<String>>,
2886    ///Property: Name
2887    #[serde(default)]
2888    pub name: Vec<String>,
2889    ///Property: Notes
2890    #[serde(skip_serializing_if = "Option::is_none")]
2891    pub notes: Option<Vec<String>>,
2892    ///Property: Previous name
2893    #[serde(skip_serializing_if = "Option::is_none")]
2894    pub previous_name: Option<Vec<String>>,
2895    ///Property: Private key
2896    #[serde(skip_serializing_if = "Option::is_none")]
2897    pub private_key: Option<Vec<String>>,
2898    ///Property: Program
2899    #[serde(skip_serializing_if = "Option::is_none")]
2900    pub program: Option<Vec<String>>,
2901    ///Property: Program ID
2902    #[serde(skip_serializing_if = "Option::is_none")]
2903    pub program_id: Option<Vec<String>>,
2904    ///Property: Source document
2905    #[serde(skip_serializing_if = "Option::is_none")]
2906    pub proof: Option<Vec<String>>,
2907    ///Property: Address
2908    #[serde(skip_serializing_if = "Option::is_none")]
2909    pub public_key: Option<Vec<String>>,
2910    ///Property: Publishing source
2911    #[serde(skip_serializing_if = "Option::is_none")]
2912    pub publisher: Option<Vec<String>>,
2913    ///Property: Publishing source URL
2914    #[serde(skip_serializing_if = "Option::is_none")]
2915    pub publisher_url: Option<Vec<String>>,
2916    ///Property: Retrieved on
2917    #[serde(skip_serializing_if = "Option::is_none")]
2918    pub retrieved_at: Option<Vec<String>>,
2919    ///Property: Source link
2920    #[serde(skip_serializing_if = "Option::is_none")]
2921    pub source_url: Option<Vec<String>>,
2922    ///Property: Summary
2923    #[serde(skip_serializing_if = "Option::is_none")]
2924    pub summary: Option<Vec<String>>,
2925    ///Property: Topics
2926    #[serde(skip_serializing_if = "Option::is_none")]
2927    pub topics: Option<Vec<String>>,
2928    ///Property: Weak alias
2929    #[serde(skip_serializing_if = "Option::is_none")]
2930    pub weak_alias: Option<Vec<String>>,
2931    ///Property: Wikidata ID
2932    #[serde(skip_serializing_if = "Option::is_none")]
2933    pub wikidata_id: Option<Vec<String>>,
2934    ///Property: Wikipedia Article
2935    #[serde(skip_serializing_if = "Option::is_none")]
2936    pub wikipedia_url: Option<Vec<String>>,
2937}
2938impl CryptoWallet {
2939    /// Create a new entity with the given ID
2940    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
2941    pub fn new(id: impl Into<String>) -> Self {
2942        Self {
2943            id: id.into(),
2944            schema: "CryptoWallet".to_string(),
2945            account_id: None,
2946            address: None,
2947            address_entity: None,
2948            aleph_url: None,
2949            alias: None,
2950            amount: None,
2951            amount_eur: None,
2952            amount_usd: None,
2953            balance: None,
2954            balance_date: None,
2955            country: None,
2956            created_at: None,
2957            creation_date: None,
2958            currency: None,
2959            currency_symbol: None,
2960            description: None,
2961            holder: None,
2962            index_text: None,
2963            keywords: None,
2964            managing_exchange: None,
2965            modified_at: None,
2966            name: Vec::new(),
2967            notes: None,
2968            previous_name: None,
2969            private_key: None,
2970            program: None,
2971            program_id: None,
2972            proof: None,
2973            public_key: None,
2974            publisher: None,
2975            publisher_url: None,
2976            retrieved_at: None,
2977            source_url: None,
2978            summary: None,
2979            topics: None,
2980            weak_alias: None,
2981            wikidata_id: None,
2982            wikipedia_url: None,
2983        }
2984    }
2985    /// Get the schema name
2986    pub fn schema_name() -> &'static str {
2987        "CryptoWallet"
2988    }
2989}
2990///FTM Schema: Debt
2991#[derive(Debug, Clone, Serialize, Deserialize)]
2992#[cfg_attr(feature = "builder", derive(Builder))]
2993#[serde(rename_all = "camelCase")]
2994pub struct Debt {
2995    pub id: String,
2996    #[cfg_attr(feature = "builder", builder(default = "Debt".to_string()))]
2997    pub schema: String,
2998    ///Property: Aleph URL
2999    #[serde(skip_serializing_if = "Option::is_none")]
3000    pub aleph_url: Option<Vec<String>>,
3001    ///Property: Amount
3002    #[serde(
3003        skip_serializing_if = "Option::is_none",
3004        deserialize_with = "deserialize_opt_f64_vec",
3005        default
3006    )]
3007    pub amount: Option<Vec<f64>>,
3008    ///Property: Amount in EUR
3009    #[serde(
3010        skip_serializing_if = "Option::is_none",
3011        deserialize_with = "deserialize_opt_f64_vec",
3012        default
3013    )]
3014    pub amount_eur: Option<Vec<f64>>,
3015    ///Property: Amount in USD
3016    #[serde(
3017        skip_serializing_if = "Option::is_none",
3018        deserialize_with = "deserialize_opt_f64_vec",
3019        default
3020    )]
3021    pub amount_usd: Option<Vec<f64>>,
3022    ///Property: Creditor
3023    #[serde(skip_serializing_if = "Option::is_none")]
3024    pub creditor: Option<Vec<String>>,
3025    ///Property: Currency
3026    #[serde(skip_serializing_if = "Option::is_none")]
3027    pub currency: Option<Vec<String>>,
3028    ///Property: Date
3029    #[serde(skip_serializing_if = "Option::is_none")]
3030    pub date: Option<Vec<String>>,
3031    ///Property: Debtor
3032    #[serde(default)]
3033    pub debtor: Vec<String>,
3034    ///Property: Description
3035    #[serde(skip_serializing_if = "Option::is_none")]
3036    pub description: Option<Vec<String>>,
3037    ///Property: End date
3038    #[serde(skip_serializing_if = "Option::is_none")]
3039    pub end_date: Option<Vec<String>>,
3040    ///Property: Index text
3041    #[serde(skip_serializing_if = "Option::is_none")]
3042    pub index_text: Option<Vec<String>>,
3043    ///Property: Modified on
3044    #[serde(skip_serializing_if = "Option::is_none")]
3045    pub modified_at: Option<Vec<String>>,
3046    ///Property: Detected names
3047    #[serde(skip_serializing_if = "Option::is_none")]
3048    pub names_mentioned: Option<Vec<String>>,
3049    ///Property: Source document
3050    #[serde(skip_serializing_if = "Option::is_none")]
3051    pub proof: Option<Vec<String>>,
3052    ///Property: Publishing source
3053    #[serde(skip_serializing_if = "Option::is_none")]
3054    pub publisher: Option<Vec<String>>,
3055    ///Property: Publishing source URL
3056    #[serde(skip_serializing_if = "Option::is_none")]
3057    pub publisher_url: Option<Vec<String>>,
3058    ///Property: Record ID
3059    #[serde(skip_serializing_if = "Option::is_none")]
3060    pub record_id: Option<Vec<String>>,
3061    ///Property: Retrieved on
3062    #[serde(skip_serializing_if = "Option::is_none")]
3063    pub retrieved_at: Option<Vec<String>>,
3064    ///Property: Source link
3065    #[serde(skip_serializing_if = "Option::is_none")]
3066    pub source_url: Option<Vec<String>>,
3067    ///Property: Start date
3068    #[serde(skip_serializing_if = "Option::is_none")]
3069    pub start_date: Option<Vec<String>>,
3070    ///Property: Summary
3071    #[serde(skip_serializing_if = "Option::is_none")]
3072    pub summary: Option<Vec<String>>,
3073}
3074impl Debt {
3075    /// Create a new entity with the given ID
3076    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
3077    pub fn new(id: impl Into<String>) -> Self {
3078        Self {
3079            id: id.into(),
3080            schema: "Debt".to_string(),
3081            aleph_url: None,
3082            amount: None,
3083            amount_eur: None,
3084            amount_usd: None,
3085            creditor: None,
3086            currency: None,
3087            date: None,
3088            debtor: Vec::new(),
3089            description: None,
3090            end_date: None,
3091            index_text: None,
3092            modified_at: None,
3093            names_mentioned: None,
3094            proof: None,
3095            publisher: None,
3096            publisher_url: None,
3097            record_id: None,
3098            retrieved_at: None,
3099            source_url: None,
3100            start_date: None,
3101            summary: None,
3102        }
3103    }
3104    /// Get the schema name
3105    pub fn schema_name() -> &'static str {
3106        "Debt"
3107    }
3108}
3109///FTM Schema: Directorship
3110#[derive(Debug, Clone, Serialize, Deserialize)]
3111#[cfg_attr(feature = "builder", derive(Builder))]
3112#[serde(rename_all = "camelCase")]
3113pub struct Directorship {
3114    pub id: String,
3115    #[cfg_attr(feature = "builder", builder(default = "Directorship".to_string()))]
3116    pub schema: String,
3117    ///Property: Aleph URL
3118    #[serde(skip_serializing_if = "Option::is_none")]
3119    pub aleph_url: Option<Vec<String>>,
3120    ///Property: Date
3121    #[serde(skip_serializing_if = "Option::is_none")]
3122    pub date: Option<Vec<String>>,
3123    ///Property: Description
3124    #[serde(skip_serializing_if = "Option::is_none")]
3125    pub description: Option<Vec<String>>,
3126    ///Property: Director
3127    #[serde(default)]
3128    pub director: Vec<String>,
3129    ///Property: End date
3130    #[serde(skip_serializing_if = "Option::is_none")]
3131    pub end_date: Option<Vec<String>>,
3132    ///Property: Index text
3133    #[serde(skip_serializing_if = "Option::is_none")]
3134    pub index_text: Option<Vec<String>>,
3135    ///Property: Modified on
3136    #[serde(skip_serializing_if = "Option::is_none")]
3137    pub modified_at: Option<Vec<String>>,
3138    ///Property: Detected names
3139    #[serde(skip_serializing_if = "Option::is_none")]
3140    pub names_mentioned: Option<Vec<String>>,
3141    ///Property: Organization
3142    #[serde(default)]
3143    pub organization: Vec<String>,
3144    ///Property: Source document
3145    #[serde(skip_serializing_if = "Option::is_none")]
3146    pub proof: Option<Vec<String>>,
3147    ///Property: Publishing source
3148    #[serde(skip_serializing_if = "Option::is_none")]
3149    pub publisher: Option<Vec<String>>,
3150    ///Property: Publishing source URL
3151    #[serde(skip_serializing_if = "Option::is_none")]
3152    pub publisher_url: Option<Vec<String>>,
3153    ///Property: Record ID
3154    #[serde(skip_serializing_if = "Option::is_none")]
3155    pub record_id: Option<Vec<String>>,
3156    ///Property: Retrieved on
3157    #[serde(skip_serializing_if = "Option::is_none")]
3158    pub retrieved_at: Option<Vec<String>>,
3159    ///Property: Role
3160    #[serde(skip_serializing_if = "Option::is_none")]
3161    pub role: Option<Vec<String>>,
3162    ///Property: Secretary
3163    #[serde(skip_serializing_if = "Option::is_none")]
3164    pub secretary: Option<Vec<String>>,
3165    ///Property: Source link
3166    #[serde(skip_serializing_if = "Option::is_none")]
3167    pub source_url: Option<Vec<String>>,
3168    ///Property: Start date
3169    #[serde(skip_serializing_if = "Option::is_none")]
3170    pub start_date: Option<Vec<String>>,
3171    ///Property: Status
3172    #[serde(skip_serializing_if = "Option::is_none")]
3173    pub status: Option<Vec<String>>,
3174    ///Property: Summary
3175    #[serde(skip_serializing_if = "Option::is_none")]
3176    pub summary: Option<Vec<String>>,
3177}
3178impl Directorship {
3179    /// Create a new entity with the given ID
3180    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
3181    pub fn new(id: impl Into<String>) -> Self {
3182        Self {
3183            id: id.into(),
3184            schema: "Directorship".to_string(),
3185            aleph_url: None,
3186            date: None,
3187            description: None,
3188            director: Vec::new(),
3189            end_date: None,
3190            index_text: None,
3191            modified_at: None,
3192            names_mentioned: None,
3193            organization: Vec::new(),
3194            proof: None,
3195            publisher: None,
3196            publisher_url: None,
3197            record_id: None,
3198            retrieved_at: None,
3199            role: None,
3200            secretary: None,
3201            source_url: None,
3202            start_date: None,
3203            status: None,
3204            summary: None,
3205        }
3206    }
3207    /// Get the schema name
3208    pub fn schema_name() -> &'static str {
3209        "Directorship"
3210    }
3211}
3212///FTM Schema: File
3213#[derive(Debug, Clone, Serialize, Deserialize)]
3214#[cfg_attr(feature = "builder", derive(Builder))]
3215#[serde(rename_all = "camelCase")]
3216pub struct Document {
3217    pub id: String,
3218    #[cfg_attr(feature = "builder", builder(default = "Document".to_string()))]
3219    pub schema: String,
3220    ///Property: Address
3221    #[serde(skip_serializing_if = "Option::is_none")]
3222    pub address: Option<Vec<String>>,
3223    ///Property: Address
3224    #[serde(skip_serializing_if = "Option::is_none")]
3225    pub address_entity: Option<Vec<String>>,
3226    ///Property: Aleph URL
3227    #[serde(skip_serializing_if = "Option::is_none")]
3228    pub aleph_url: Option<Vec<String>>,
3229    ///Property: Alias
3230    #[serde(skip_serializing_if = "Option::is_none")]
3231    pub alias: Option<Vec<String>>,
3232    ///Property: Ancestors
3233    #[serde(skip_serializing_if = "Option::is_none")]
3234    pub ancestors: Option<Vec<String>>,
3235    ///Property: Author
3236    #[serde(skip_serializing_if = "Option::is_none")]
3237    pub author: Option<Vec<String>>,
3238    ///Property: Authored on
3239    #[serde(skip_serializing_if = "Option::is_none")]
3240    pub authored_at: Option<Vec<String>>,
3241    ///Property: Text
3242    #[serde(skip_serializing_if = "Option::is_none")]
3243    pub body_text: Option<Vec<String>>,
3244    ///Property: Detected companies
3245    #[serde(skip_serializing_if = "Option::is_none")]
3246    pub companies_mentioned: Option<Vec<String>>,
3247    ///Property: Checksum
3248    #[serde(skip_serializing_if = "Option::is_none")]
3249    pub content_hash: Option<Vec<String>>,
3250    ///Property: Country
3251    #[serde(skip_serializing_if = "Option::is_none")]
3252    pub country: Option<Vec<String>>,
3253    ///Property: Crawler
3254    #[serde(skip_serializing_if = "Option::is_none")]
3255    pub crawler: Option<Vec<String>>,
3256    ///Property: Created at
3257    #[serde(skip_serializing_if = "Option::is_none")]
3258    pub created_at: Option<Vec<String>>,
3259    ///Property: Date
3260    #[serde(skip_serializing_if = "Option::is_none")]
3261    pub date: Option<Vec<String>>,
3262    ///Property: Description
3263    #[serde(skip_serializing_if = "Option::is_none")]
3264    pub description: Option<Vec<String>>,
3265    ///Property: Detected country
3266    #[serde(skip_serializing_if = "Option::is_none")]
3267    pub detected_country: Option<Vec<String>>,
3268    ///Property: Detected language
3269    #[serde(skip_serializing_if = "Option::is_none")]
3270    pub detected_language: Option<Vec<String>>,
3271    ///Property: Detected e-mail addresses
3272    #[serde(skip_serializing_if = "Option::is_none")]
3273    pub email_mentioned: Option<Vec<String>>,
3274    ///Property: File encoding
3275    #[serde(skip_serializing_if = "Option::is_none")]
3276    pub encoding: Option<Vec<String>>,
3277    ///Property: File extension
3278    #[serde(skip_serializing_if = "Option::is_none")]
3279    pub extension: Option<Vec<String>>,
3280    ///Property: File name
3281    #[serde(default)]
3282    pub file_name: Vec<String>,
3283    ///Property: File size
3284    #[serde(
3285        skip_serializing_if = "Option::is_none",
3286        deserialize_with = "deserialize_opt_f64_vec",
3287        default
3288    )]
3289    pub file_size: Option<Vec<f64>>,
3290    ///Property: Generator
3291    #[serde(skip_serializing_if = "Option::is_none")]
3292    pub generator: Option<Vec<String>>,
3293    ///Property: Detected IBANs
3294    #[serde(skip_serializing_if = "Option::is_none")]
3295    pub iban_mentioned: Option<Vec<String>>,
3296    ///Property: Index text
3297    #[serde(skip_serializing_if = "Option::is_none")]
3298    pub index_text: Option<Vec<String>>,
3299    ///Property: Detected IP addresses
3300    #[serde(skip_serializing_if = "Option::is_none")]
3301    pub ip_mentioned: Option<Vec<String>>,
3302    ///Property: Keywords
3303    #[serde(skip_serializing_if = "Option::is_none")]
3304    pub keywords: Option<Vec<String>>,
3305    ///Property: Language
3306    #[serde(skip_serializing_if = "Option::is_none")]
3307    pub language: Option<Vec<String>>,
3308    ///Property: Detected locations
3309    #[serde(skip_serializing_if = "Option::is_none")]
3310    pub location_mentioned: Option<Vec<String>>,
3311    ///Property: Message ID
3312    #[serde(skip_serializing_if = "Option::is_none")]
3313    pub message_id: Option<Vec<String>>,
3314    ///Property: MIME type
3315    #[serde(skip_serializing_if = "Option::is_none")]
3316    pub mime_type: Option<Vec<String>>,
3317    ///Property: Modified on
3318    #[serde(skip_serializing_if = "Option::is_none")]
3319    pub modified_at: Option<Vec<String>>,
3320    ///Property: Name
3321    #[serde(default)]
3322    pub name: Vec<String>,
3323    ///Property: Detected names
3324    #[serde(skip_serializing_if = "Option::is_none")]
3325    pub names_mentioned: Option<Vec<String>>,
3326    ///Property: Notes
3327    #[serde(skip_serializing_if = "Option::is_none")]
3328    pub notes: Option<Vec<String>>,
3329    ///Property: Folder
3330    #[serde(skip_serializing_if = "Option::is_none")]
3331    pub parent: Option<Vec<String>>,
3332    ///Property: Detected people
3333    #[serde(skip_serializing_if = "Option::is_none")]
3334    pub people_mentioned: Option<Vec<String>>,
3335    ///Property: Detected phones
3336    #[serde(skip_serializing_if = "Option::is_none")]
3337    pub phone_mentioned: Option<Vec<String>>,
3338    ///Property: Previous name
3339    #[serde(skip_serializing_if = "Option::is_none")]
3340    pub previous_name: Option<Vec<String>>,
3341    ///Property: Processed at
3342    #[serde(skip_serializing_if = "Option::is_none")]
3343    pub processed_at: Option<Vec<String>>,
3344    ///Property: Processing agent
3345    #[serde(skip_serializing_if = "Option::is_none")]
3346    pub processing_agent: Option<Vec<String>>,
3347    ///Property: Processing error
3348    #[serde(skip_serializing_if = "Option::is_none")]
3349    pub processing_error: Option<Vec<String>>,
3350    ///Property: Processing status
3351    #[serde(skip_serializing_if = "Option::is_none")]
3352    pub processing_status: Option<Vec<String>>,
3353    ///Property: Program
3354    #[serde(skip_serializing_if = "Option::is_none")]
3355    pub program: Option<Vec<String>>,
3356    ///Property: Program ID
3357    #[serde(skip_serializing_if = "Option::is_none")]
3358    pub program_id: Option<Vec<String>>,
3359    ///Property: Source document
3360    #[serde(skip_serializing_if = "Option::is_none")]
3361    pub proof: Option<Vec<String>>,
3362    ///Property: Published on
3363    #[serde(skip_serializing_if = "Option::is_none")]
3364    pub published_at: Option<Vec<String>>,
3365    ///Property: Publishing source
3366    #[serde(skip_serializing_if = "Option::is_none")]
3367    pub publisher: Option<Vec<String>>,
3368    ///Property: Publishing source URL
3369    #[serde(skip_serializing_if = "Option::is_none")]
3370    pub publisher_url: Option<Vec<String>>,
3371    ///Property: Retrieved on
3372    #[serde(skip_serializing_if = "Option::is_none")]
3373    pub retrieved_at: Option<Vec<String>>,
3374    ///Property: Source link
3375    #[serde(skip_serializing_if = "Option::is_none")]
3376    pub source_url: Option<Vec<String>>,
3377    ///Property: Summary
3378    #[serde(skip_serializing_if = "Option::is_none")]
3379    pub summary: Option<Vec<String>>,
3380    ///Property: Title
3381    #[serde(skip_serializing_if = "Option::is_none")]
3382    pub title: Option<Vec<String>>,
3383    ///Property: Topics
3384    #[serde(skip_serializing_if = "Option::is_none")]
3385    pub topics: Option<Vec<String>>,
3386    ///Property: The language of the translated text
3387    #[serde(skip_serializing_if = "Option::is_none")]
3388    pub translated_language: Option<Vec<String>>,
3389    ///Property: Translated version of the body text
3390    #[serde(skip_serializing_if = "Option::is_none")]
3391    pub translated_text: Option<Vec<String>>,
3392    ///Property: Weak alias
3393    #[serde(skip_serializing_if = "Option::is_none")]
3394    pub weak_alias: Option<Vec<String>>,
3395    ///Property: Wikidata ID
3396    #[serde(skip_serializing_if = "Option::is_none")]
3397    pub wikidata_id: Option<Vec<String>>,
3398    ///Property: Wikipedia Article
3399    #[serde(skip_serializing_if = "Option::is_none")]
3400    pub wikipedia_url: Option<Vec<String>>,
3401}
3402impl Document {
3403    /// Create a new entity with the given ID
3404    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
3405    pub fn new(id: impl Into<String>) -> Self {
3406        Self {
3407            id: id.into(),
3408            schema: "Document".to_string(),
3409            address: None,
3410            address_entity: None,
3411            aleph_url: None,
3412            alias: None,
3413            ancestors: None,
3414            author: None,
3415            authored_at: None,
3416            body_text: None,
3417            companies_mentioned: None,
3418            content_hash: None,
3419            country: None,
3420            crawler: None,
3421            created_at: None,
3422            date: None,
3423            description: None,
3424            detected_country: None,
3425            detected_language: None,
3426            email_mentioned: None,
3427            encoding: None,
3428            extension: None,
3429            file_name: Vec::new(),
3430            file_size: None,
3431            generator: None,
3432            iban_mentioned: None,
3433            index_text: None,
3434            ip_mentioned: None,
3435            keywords: None,
3436            language: None,
3437            location_mentioned: None,
3438            message_id: None,
3439            mime_type: None,
3440            modified_at: None,
3441            name: Vec::new(),
3442            names_mentioned: None,
3443            notes: None,
3444            parent: None,
3445            people_mentioned: None,
3446            phone_mentioned: None,
3447            previous_name: None,
3448            processed_at: None,
3449            processing_agent: None,
3450            processing_error: None,
3451            processing_status: None,
3452            program: None,
3453            program_id: None,
3454            proof: None,
3455            published_at: None,
3456            publisher: None,
3457            publisher_url: None,
3458            retrieved_at: None,
3459            source_url: None,
3460            summary: None,
3461            title: None,
3462            topics: None,
3463            translated_language: None,
3464            translated_text: None,
3465            weak_alias: None,
3466            wikidata_id: None,
3467            wikipedia_url: None,
3468        }
3469    }
3470    /// Get the schema name
3471    pub fn schema_name() -> &'static str {
3472        "Document"
3473    }
3474}
3475///FTM Schema: Documentation
3476#[derive(Debug, Clone, Serialize, Deserialize)]
3477#[cfg_attr(feature = "builder", derive(Builder))]
3478#[serde(rename_all = "camelCase")]
3479pub struct Documentation {
3480    pub id: String,
3481    #[cfg_attr(feature = "builder", builder(default = "Documentation".to_string()))]
3482    pub schema: String,
3483    ///Property: Aleph URL
3484    #[serde(skip_serializing_if = "Option::is_none")]
3485    pub aleph_url: Option<Vec<String>>,
3486    ///Property: Date
3487    #[serde(skip_serializing_if = "Option::is_none")]
3488    pub date: Option<Vec<String>>,
3489    ///Property: Description
3490    #[serde(skip_serializing_if = "Option::is_none")]
3491    pub description: Option<Vec<String>>,
3492    ///Property: Document
3493    #[serde(default)]
3494    pub document: Vec<String>,
3495    ///Property: End date
3496    #[serde(skip_serializing_if = "Option::is_none")]
3497    pub end_date: Option<Vec<String>>,
3498    ///Property: Entity
3499    #[serde(default)]
3500    pub entity: Vec<String>,
3501    ///Property: Index text
3502    #[serde(skip_serializing_if = "Option::is_none")]
3503    pub index_text: Option<Vec<String>>,
3504    ///Property: Modified on
3505    #[serde(skip_serializing_if = "Option::is_none")]
3506    pub modified_at: Option<Vec<String>>,
3507    ///Property: Detected names
3508    #[serde(skip_serializing_if = "Option::is_none")]
3509    pub names_mentioned: Option<Vec<String>>,
3510    ///Property: Source document
3511    #[serde(skip_serializing_if = "Option::is_none")]
3512    pub proof: Option<Vec<String>>,
3513    ///Property: Publishing source
3514    #[serde(skip_serializing_if = "Option::is_none")]
3515    pub publisher: Option<Vec<String>>,
3516    ///Property: Publishing source URL
3517    #[serde(skip_serializing_if = "Option::is_none")]
3518    pub publisher_url: Option<Vec<String>>,
3519    ///Property: Record ID
3520    #[serde(skip_serializing_if = "Option::is_none")]
3521    pub record_id: Option<Vec<String>>,
3522    ///Property: Retrieved on
3523    #[serde(skip_serializing_if = "Option::is_none")]
3524    pub retrieved_at: Option<Vec<String>>,
3525    ///Property: Role
3526    #[serde(skip_serializing_if = "Option::is_none")]
3527    pub role: Option<Vec<String>>,
3528    ///Property: Source link
3529    #[serde(skip_serializing_if = "Option::is_none")]
3530    pub source_url: Option<Vec<String>>,
3531    ///Property: Start date
3532    #[serde(skip_serializing_if = "Option::is_none")]
3533    pub start_date: Option<Vec<String>>,
3534    ///Property: Status
3535    #[serde(skip_serializing_if = "Option::is_none")]
3536    pub status: Option<Vec<String>>,
3537    ///Property: Summary
3538    #[serde(skip_serializing_if = "Option::is_none")]
3539    pub summary: Option<Vec<String>>,
3540}
3541impl Documentation {
3542    /// Create a new entity with the given ID
3543    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
3544    pub fn new(id: impl Into<String>) -> Self {
3545        Self {
3546            id: id.into(),
3547            schema: "Documentation".to_string(),
3548            aleph_url: None,
3549            date: None,
3550            description: None,
3551            document: Vec::new(),
3552            end_date: None,
3553            entity: Vec::new(),
3554            index_text: None,
3555            modified_at: None,
3556            names_mentioned: None,
3557            proof: None,
3558            publisher: None,
3559            publisher_url: None,
3560            record_id: None,
3561            retrieved_at: None,
3562            role: None,
3563            source_url: None,
3564            start_date: None,
3565            status: None,
3566            summary: None,
3567        }
3568    }
3569    /// Get the schema name
3570    pub fn schema_name() -> &'static str {
3571        "Documentation"
3572    }
3573}
3574///FTM Schema: Customs declaration
3575#[derive(Debug, Clone, Serialize, Deserialize)]
3576#[cfg_attr(feature = "builder", derive(Builder))]
3577#[serde(rename_all = "camelCase")]
3578pub struct EconomicActivity {
3579    pub id: String,
3580    #[cfg_attr(feature = "builder", builder(default = "EconomicActivity".to_string()))]
3581    pub schema: String,
3582    ///Property: Aleph URL
3583    #[serde(skip_serializing_if = "Option::is_none")]
3584    pub aleph_url: Option<Vec<String>>,
3585    ///Property: Bank Account
3586    #[serde(skip_serializing_if = "Option::is_none")]
3587    pub bank_account: Option<Vec<String>>,
3588    ///Property: Foreign currency bank
3589    #[serde(skip_serializing_if = "Option::is_none")]
3590    pub bank_foreign: Option<Vec<String>>,
3591    ///Property: Rouble bank
3592    #[serde(skip_serializing_if = "Option::is_none")]
3593    pub bank_rub: Option<Vec<String>>,
3594    ///Property: Customs Cargo Declaration Number
3595    #[serde(skip_serializing_if = "Option::is_none")]
3596    pub ccd_number: Option<Vec<String>>,
3597    ///Property: CCD Value
3598    #[serde(skip_serializing_if = "Option::is_none")]
3599    pub ccd_value: Option<Vec<String>>,
3600    ///Property: Contract
3601    #[serde(skip_serializing_if = "Option::is_none")]
3602    pub contract: Option<Vec<String>>,
3603    ///Property: Contract holder
3604    #[serde(skip_serializing_if = "Option::is_none")]
3605    pub contract_holder: Option<Vec<String>>,
3606    ///Property: Customs Value Amount
3607    #[serde(skip_serializing_if = "Option::is_none")]
3608    pub customs_amount: Option<Vec<String>>,
3609    ///Property: Customs Procedure
3610    #[serde(skip_serializing_if = "Option::is_none")]
3611    pub customs_procedure: Option<Vec<String>>,
3612    ///Property: Date
3613    #[serde(skip_serializing_if = "Option::is_none")]
3614    pub date: Option<Vec<String>>,
3615    ///Property: Declarant
3616    #[serde(skip_serializing_if = "Option::is_none")]
3617    pub declarant: Option<Vec<String>>,
3618    ///Property: Country of departure
3619    #[serde(skip_serializing_if = "Option::is_none")]
3620    pub departure_country: Option<Vec<String>>,
3621    ///Property: Description
3622    #[serde(skip_serializing_if = "Option::is_none")]
3623    pub description: Option<Vec<String>>,
3624    ///Property: Country of destination
3625    #[serde(skip_serializing_if = "Option::is_none")]
3626    pub destination_country: Option<Vec<String>>,
3627    ///Property: Direction of transportation
3628    #[serde(skip_serializing_if = "Option::is_none")]
3629    pub direction_of_transportation: Option<Vec<String>>,
3630    ///Property: USD Exchange Rate
3631    #[serde(skip_serializing_if = "Option::is_none")]
3632    pub dollar_exch_rate: Option<Vec<String>>,
3633    ///Property: End date
3634    #[serde(skip_serializing_if = "Option::is_none")]
3635    pub end_date: Option<Vec<String>>,
3636    ///Property: Description of goods
3637    #[serde(skip_serializing_if = "Option::is_none")]
3638    pub goods_description: Option<Vec<String>>,
3639    ///Property: Index text
3640    #[serde(skip_serializing_if = "Option::is_none")]
3641    pub index_text: Option<Vec<String>>,
3642    ///Property: Invoice Value Amount
3643    #[serde(skip_serializing_if = "Option::is_none")]
3644    pub invoice_amount: Option<Vec<String>>,
3645    ///Property: Modified on
3646    #[serde(skip_serializing_if = "Option::is_none")]
3647    pub modified_at: Option<Vec<String>>,
3648    ///Property: Detected names
3649    #[serde(skip_serializing_if = "Option::is_none")]
3650    pub names_mentioned: Option<Vec<String>>,
3651    ///Property: Country of origin
3652    #[serde(skip_serializing_if = "Option::is_none")]
3653    pub origin_country: Option<Vec<String>>,
3654    ///Property: Source document
3655    #[serde(skip_serializing_if = "Option::is_none")]
3656    pub proof: Option<Vec<String>>,
3657    ///Property: Publishing source
3658    #[serde(skip_serializing_if = "Option::is_none")]
3659    pub publisher: Option<Vec<String>>,
3660    ///Property: Publishing source URL
3661    #[serde(skip_serializing_if = "Option::is_none")]
3662    pub publisher_url: Option<Vec<String>>,
3663    ///Property: Receiver
3664    #[serde(skip_serializing_if = "Option::is_none")]
3665    pub receiver: Option<Vec<String>>,
3666    ///Property: Record ID
3667    #[serde(skip_serializing_if = "Option::is_none")]
3668    pub record_id: Option<Vec<String>>,
3669    ///Property: Retrieved on
3670    #[serde(skip_serializing_if = "Option::is_none")]
3671    pub retrieved_at: Option<Vec<String>>,
3672    ///Property: Sender
3673    #[serde(skip_serializing_if = "Option::is_none")]
3674    pub sender: Option<Vec<String>>,
3675    ///Property: Source link
3676    #[serde(skip_serializing_if = "Option::is_none")]
3677    pub source_url: Option<Vec<String>>,
3678    ///Property: Start date
3679    #[serde(skip_serializing_if = "Option::is_none")]
3680    pub start_date: Option<Vec<String>>,
3681    ///Property: Summary
3682    #[serde(skip_serializing_if = "Option::is_none")]
3683    pub summary: Option<Vec<String>>,
3684    ///Property: Trading Country
3685    #[serde(skip_serializing_if = "Option::is_none")]
3686    pub trading_country: Option<Vec<String>>,
3687    ///Property: Transport
3688    #[serde(skip_serializing_if = "Option::is_none")]
3689    pub transport: Option<Vec<String>>,
3690    ///Property: FEAC Code
3691    #[serde(skip_serializing_if = "Option::is_none")]
3692    pub ved_code: Option<Vec<String>>,
3693    ///Property: FEAC Code description
3694    #[serde(skip_serializing_if = "Option::is_none")]
3695    pub ved_code_description: Option<Vec<String>>,
3696}
3697impl EconomicActivity {
3698    /// Create a new entity with the given ID
3699    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
3700    pub fn new(id: impl Into<String>) -> Self {
3701        Self {
3702            id: id.into(),
3703            schema: "EconomicActivity".to_string(),
3704            aleph_url: None,
3705            bank_account: None,
3706            bank_foreign: None,
3707            bank_rub: None,
3708            ccd_number: None,
3709            ccd_value: None,
3710            contract: None,
3711            contract_holder: None,
3712            customs_amount: None,
3713            customs_procedure: None,
3714            date: None,
3715            declarant: None,
3716            departure_country: None,
3717            description: None,
3718            destination_country: None,
3719            direction_of_transportation: None,
3720            dollar_exch_rate: None,
3721            end_date: None,
3722            goods_description: None,
3723            index_text: None,
3724            invoice_amount: None,
3725            modified_at: None,
3726            names_mentioned: None,
3727            origin_country: None,
3728            proof: None,
3729            publisher: None,
3730            publisher_url: None,
3731            receiver: None,
3732            record_id: None,
3733            retrieved_at: None,
3734            sender: None,
3735            source_url: None,
3736            start_date: None,
3737            summary: None,
3738            trading_country: None,
3739            transport: None,
3740            ved_code: None,
3741            ved_code_description: None,
3742        }
3743    }
3744    /// Get the schema name
3745    pub fn schema_name() -> &'static str {
3746        "EconomicActivity"
3747    }
3748}
3749///FTM Schema: E-Mail
3750#[derive(Debug, Clone, Serialize, Deserialize)]
3751#[cfg_attr(feature = "builder", derive(Builder))]
3752#[serde(rename_all = "camelCase")]
3753pub struct Email {
3754    pub id: String,
3755    #[cfg_attr(feature = "builder", builder(default = "Email".to_string()))]
3756    pub schema: String,
3757    ///Property: Address
3758    #[serde(skip_serializing_if = "Option::is_none")]
3759    pub address: Option<Vec<String>>,
3760    ///Property: Address
3761    #[serde(skip_serializing_if = "Option::is_none")]
3762    pub address_entity: Option<Vec<String>>,
3763    ///Property: Aleph URL
3764    #[serde(skip_serializing_if = "Option::is_none")]
3765    pub aleph_url: Option<Vec<String>>,
3766    ///Property: Alias
3767    #[serde(skip_serializing_if = "Option::is_none")]
3768    pub alias: Option<Vec<String>>,
3769    ///Property: Ancestors
3770    #[serde(skip_serializing_if = "Option::is_none")]
3771    pub ancestors: Option<Vec<String>>,
3772    ///Property: Author
3773    #[serde(skip_serializing_if = "Option::is_none")]
3774    pub author: Option<Vec<String>>,
3775    ///Property: Authored on
3776    #[serde(skip_serializing_if = "Option::is_none")]
3777    pub authored_at: Option<Vec<String>>,
3778    ///Property: BCC
3779    #[serde(skip_serializing_if = "Option::is_none")]
3780    pub bcc: Option<Vec<String>>,
3781    ///Property: HTML
3782    #[serde(skip_serializing_if = "Option::is_none")]
3783    pub body_html: Option<Vec<String>>,
3784    ///Property: Text
3785    #[serde(skip_serializing_if = "Option::is_none")]
3786    pub body_text: Option<Vec<String>>,
3787    ///Property: CC
3788    #[serde(skip_serializing_if = "Option::is_none")]
3789    pub cc: Option<Vec<String>>,
3790    ///Property: Detected companies
3791    #[serde(skip_serializing_if = "Option::is_none")]
3792    pub companies_mentioned: Option<Vec<String>>,
3793    ///Property: Checksum
3794    #[serde(skip_serializing_if = "Option::is_none")]
3795    pub content_hash: Option<Vec<String>>,
3796    ///Property: Country
3797    #[serde(skip_serializing_if = "Option::is_none")]
3798    pub country: Option<Vec<String>>,
3799    ///Property: Crawler
3800    #[serde(skip_serializing_if = "Option::is_none")]
3801    pub crawler: Option<Vec<String>>,
3802    ///Property: Created at
3803    #[serde(skip_serializing_if = "Option::is_none")]
3804    pub created_at: Option<Vec<String>>,
3805    ///Property: Date
3806    #[serde(skip_serializing_if = "Option::is_none")]
3807    pub date: Option<Vec<String>>,
3808    ///Property: Description
3809    #[serde(skip_serializing_if = "Option::is_none")]
3810    pub description: Option<Vec<String>>,
3811    ///Property: Detected country
3812    #[serde(skip_serializing_if = "Option::is_none")]
3813    pub detected_country: Option<Vec<String>>,
3814    ///Property: Detected language
3815    #[serde(skip_serializing_if = "Option::is_none")]
3816    pub detected_language: Option<Vec<String>>,
3817    ///Property: Detected e-mail addresses
3818    #[serde(skip_serializing_if = "Option::is_none")]
3819    pub email_mentioned: Option<Vec<String>>,
3820    ///Property: Emitter
3821    #[serde(skip_serializing_if = "Option::is_none")]
3822    pub emitters: Option<Vec<String>>,
3823    ///Property: File encoding
3824    #[serde(skip_serializing_if = "Option::is_none")]
3825    pub encoding: Option<Vec<String>>,
3826    ///Property: File extension
3827    #[serde(skip_serializing_if = "Option::is_none")]
3828    pub extension: Option<Vec<String>>,
3829    ///Property: File name
3830    #[serde(default)]
3831    pub file_name: Vec<String>,
3832    ///Property: File size
3833    #[serde(
3834        skip_serializing_if = "Option::is_none",
3835        deserialize_with = "deserialize_opt_f64_vec",
3836        default
3837    )]
3838    pub file_size: Option<Vec<f64>>,
3839    ///Property: From
3840    #[serde(skip_serializing_if = "Option::is_none")]
3841    pub from: Option<Vec<String>>,
3842    ///Property: Generator
3843    #[serde(skip_serializing_if = "Option::is_none")]
3844    pub generator: Option<Vec<String>>,
3845    ///Property: Raw headers
3846    #[serde(skip_serializing_if = "Option::is_none")]
3847    pub headers: Option<serde_json::Value>,
3848    ///Property: Detected IBANs
3849    #[serde(skip_serializing_if = "Option::is_none")]
3850    pub iban_mentioned: Option<Vec<String>>,
3851    ///Property: In Reply To
3852    #[serde(skip_serializing_if = "Option::is_none")]
3853    pub in_reply_to: Option<Vec<String>>,
3854    ///Property: Responding to
3855    #[serde(skip_serializing_if = "Option::is_none")]
3856    pub in_reply_to_email: Option<Vec<String>>,
3857    ///Property: Index text
3858    #[serde(skip_serializing_if = "Option::is_none")]
3859    pub index_text: Option<Vec<String>>,
3860    ///Property: Detected IP addresses
3861    #[serde(skip_serializing_if = "Option::is_none")]
3862    pub ip_mentioned: Option<Vec<String>>,
3863    ///Property: Keywords
3864    #[serde(skip_serializing_if = "Option::is_none")]
3865    pub keywords: Option<Vec<String>>,
3866    ///Property: Language
3867    #[serde(skip_serializing_if = "Option::is_none")]
3868    pub language: Option<Vec<String>>,
3869    ///Property: Detected locations
3870    #[serde(skip_serializing_if = "Option::is_none")]
3871    pub location_mentioned: Option<Vec<String>>,
3872    ///Property: Message ID
3873    #[serde(skip_serializing_if = "Option::is_none")]
3874    pub message_id: Option<Vec<String>>,
3875    ///Property: MIME type
3876    #[serde(skip_serializing_if = "Option::is_none")]
3877    pub mime_type: Option<Vec<String>>,
3878    ///Property: Modified on
3879    #[serde(skip_serializing_if = "Option::is_none")]
3880    pub modified_at: Option<Vec<String>>,
3881    ///Property: Name
3882    #[serde(default)]
3883    pub name: Vec<String>,
3884    ///Property: Detected names
3885    #[serde(skip_serializing_if = "Option::is_none")]
3886    pub names_mentioned: Option<Vec<String>>,
3887    ///Property: Notes
3888    #[serde(skip_serializing_if = "Option::is_none")]
3889    pub notes: Option<Vec<String>>,
3890    ///Property: Folder
3891    #[serde(skip_serializing_if = "Option::is_none")]
3892    pub parent: Option<Vec<String>>,
3893    ///Property: Detected people
3894    #[serde(skip_serializing_if = "Option::is_none")]
3895    pub people_mentioned: Option<Vec<String>>,
3896    ///Property: Detected phones
3897    #[serde(skip_serializing_if = "Option::is_none")]
3898    pub phone_mentioned: Option<Vec<String>>,
3899    ///Property: Previous name
3900    #[serde(skip_serializing_if = "Option::is_none")]
3901    pub previous_name: Option<Vec<String>>,
3902    ///Property: Processed at
3903    #[serde(skip_serializing_if = "Option::is_none")]
3904    pub processed_at: Option<Vec<String>>,
3905    ///Property: Processing agent
3906    #[serde(skip_serializing_if = "Option::is_none")]
3907    pub processing_agent: Option<Vec<String>>,
3908    ///Property: Processing error
3909    #[serde(skip_serializing_if = "Option::is_none")]
3910    pub processing_error: Option<Vec<String>>,
3911    ///Property: Processing status
3912    #[serde(skip_serializing_if = "Option::is_none")]
3913    pub processing_status: Option<Vec<String>>,
3914    ///Property: Program
3915    #[serde(skip_serializing_if = "Option::is_none")]
3916    pub program: Option<Vec<String>>,
3917    ///Property: Program ID
3918    #[serde(skip_serializing_if = "Option::is_none")]
3919    pub program_id: Option<Vec<String>>,
3920    ///Property: Source document
3921    #[serde(skip_serializing_if = "Option::is_none")]
3922    pub proof: Option<Vec<String>>,
3923    ///Property: Published on
3924    #[serde(skip_serializing_if = "Option::is_none")]
3925    pub published_at: Option<Vec<String>>,
3926    ///Property: Publishing source
3927    #[serde(skip_serializing_if = "Option::is_none")]
3928    pub publisher: Option<Vec<String>>,
3929    ///Property: Publishing source URL
3930    #[serde(skip_serializing_if = "Option::is_none")]
3931    pub publisher_url: Option<Vec<String>>,
3932    ///Property: Recipients
3933    #[serde(skip_serializing_if = "Option::is_none")]
3934    pub recipients: Option<Vec<String>>,
3935    ///Property: Retrieved on
3936    #[serde(skip_serializing_if = "Option::is_none")]
3937    pub retrieved_at: Option<Vec<String>>,
3938    ///Property: Sender
3939    #[serde(skip_serializing_if = "Option::is_none")]
3940    pub sender: Option<Vec<String>>,
3941    ///Property: Source link
3942    #[serde(skip_serializing_if = "Option::is_none")]
3943    pub source_url: Option<Vec<String>>,
3944    ///Property: Subject
3945    #[serde(skip_serializing_if = "Option::is_none")]
3946    pub subject: Option<Vec<String>>,
3947    ///Property: Summary
3948    #[serde(skip_serializing_if = "Option::is_none")]
3949    pub summary: Option<Vec<String>>,
3950    ///Property: Thread topic
3951    #[serde(skip_serializing_if = "Option::is_none")]
3952    pub thread_topic: Option<Vec<String>>,
3953    ///Property: Title
3954    #[serde(skip_serializing_if = "Option::is_none")]
3955    pub title: Option<Vec<String>>,
3956    ///Property: To
3957    #[serde(skip_serializing_if = "Option::is_none")]
3958    pub to: Option<Vec<String>>,
3959    ///Property: Topics
3960    #[serde(skip_serializing_if = "Option::is_none")]
3961    pub topics: Option<Vec<String>>,
3962    ///Property: The language of the translated text
3963    #[serde(skip_serializing_if = "Option::is_none")]
3964    pub translated_language: Option<Vec<String>>,
3965    ///Property: Translated version of the body text
3966    #[serde(skip_serializing_if = "Option::is_none")]
3967    pub translated_text: Option<Vec<String>>,
3968    ///Property: Weak alias
3969    #[serde(skip_serializing_if = "Option::is_none")]
3970    pub weak_alias: Option<Vec<String>>,
3971    ///Property: Wikidata ID
3972    #[serde(skip_serializing_if = "Option::is_none")]
3973    pub wikidata_id: Option<Vec<String>>,
3974    ///Property: Wikipedia Article
3975    #[serde(skip_serializing_if = "Option::is_none")]
3976    pub wikipedia_url: Option<Vec<String>>,
3977}
3978impl Email {
3979    /// Create a new entity with the given ID
3980    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
3981    pub fn new(id: impl Into<String>) -> Self {
3982        Self {
3983            id: id.into(),
3984            schema: "Email".to_string(),
3985            address: None,
3986            address_entity: None,
3987            aleph_url: None,
3988            alias: None,
3989            ancestors: None,
3990            author: None,
3991            authored_at: None,
3992            bcc: None,
3993            body_html: None,
3994            body_text: None,
3995            cc: None,
3996            companies_mentioned: None,
3997            content_hash: None,
3998            country: None,
3999            crawler: None,
4000            created_at: None,
4001            date: None,
4002            description: None,
4003            detected_country: None,
4004            detected_language: None,
4005            email_mentioned: None,
4006            emitters: None,
4007            encoding: None,
4008            extension: None,
4009            file_name: Vec::new(),
4010            file_size: None,
4011            from: None,
4012            generator: None,
4013            headers: None,
4014            iban_mentioned: None,
4015            in_reply_to: None,
4016            in_reply_to_email: None,
4017            index_text: None,
4018            ip_mentioned: None,
4019            keywords: None,
4020            language: None,
4021            location_mentioned: None,
4022            message_id: None,
4023            mime_type: None,
4024            modified_at: None,
4025            name: Vec::new(),
4026            names_mentioned: None,
4027            notes: None,
4028            parent: None,
4029            people_mentioned: None,
4030            phone_mentioned: None,
4031            previous_name: None,
4032            processed_at: None,
4033            processing_agent: None,
4034            processing_error: None,
4035            processing_status: None,
4036            program: None,
4037            program_id: None,
4038            proof: None,
4039            published_at: None,
4040            publisher: None,
4041            publisher_url: None,
4042            recipients: None,
4043            retrieved_at: None,
4044            sender: None,
4045            source_url: None,
4046            subject: None,
4047            summary: None,
4048            thread_topic: None,
4049            title: None,
4050            to: None,
4051            topics: None,
4052            translated_language: None,
4053            translated_text: None,
4054            weak_alias: None,
4055            wikidata_id: None,
4056            wikipedia_url: None,
4057        }
4058    }
4059    /// Get the schema name
4060    pub fn schema_name() -> &'static str {
4061        "Email"
4062    }
4063}
4064///FTM Schema: Employment
4065#[derive(Debug, Clone, Serialize, Deserialize)]
4066#[cfg_attr(feature = "builder", derive(Builder))]
4067#[serde(rename_all = "camelCase")]
4068pub struct Employment {
4069    pub id: String,
4070    #[cfg_attr(feature = "builder", builder(default = "Employment".to_string()))]
4071    pub schema: String,
4072    ///Property: Aleph URL
4073    #[serde(skip_serializing_if = "Option::is_none")]
4074    pub aleph_url: Option<Vec<String>>,
4075    ///Property: Date
4076    #[serde(skip_serializing_if = "Option::is_none")]
4077    pub date: Option<Vec<String>>,
4078    ///Property: Description
4079    #[serde(skip_serializing_if = "Option::is_none")]
4080    pub description: Option<Vec<String>>,
4081    ///Property: Employee
4082    #[serde(default)]
4083    pub employee: Vec<String>,
4084    ///Property: Employer
4085    #[serde(default)]
4086    pub employer: Vec<String>,
4087    ///Property: End date
4088    #[serde(skip_serializing_if = "Option::is_none")]
4089    pub end_date: Option<Vec<String>>,
4090    ///Property: Index text
4091    #[serde(skip_serializing_if = "Option::is_none")]
4092    pub index_text: Option<Vec<String>>,
4093    ///Property: Modified on
4094    #[serde(skip_serializing_if = "Option::is_none")]
4095    pub modified_at: Option<Vec<String>>,
4096    ///Property: Detected names
4097    #[serde(skip_serializing_if = "Option::is_none")]
4098    pub names_mentioned: Option<Vec<String>>,
4099    ///Property: Source document
4100    #[serde(skip_serializing_if = "Option::is_none")]
4101    pub proof: Option<Vec<String>>,
4102    ///Property: Publishing source
4103    #[serde(skip_serializing_if = "Option::is_none")]
4104    pub publisher: Option<Vec<String>>,
4105    ///Property: Publishing source URL
4106    #[serde(skip_serializing_if = "Option::is_none")]
4107    pub publisher_url: Option<Vec<String>>,
4108    ///Property: Record ID
4109    #[serde(skip_serializing_if = "Option::is_none")]
4110    pub record_id: Option<Vec<String>>,
4111    ///Property: Retrieved on
4112    #[serde(skip_serializing_if = "Option::is_none")]
4113    pub retrieved_at: Option<Vec<String>>,
4114    ///Property: Role
4115    #[serde(skip_serializing_if = "Option::is_none")]
4116    pub role: Option<Vec<String>>,
4117    ///Property: Source link
4118    #[serde(skip_serializing_if = "Option::is_none")]
4119    pub source_url: Option<Vec<String>>,
4120    ///Property: Start date
4121    #[serde(skip_serializing_if = "Option::is_none")]
4122    pub start_date: Option<Vec<String>>,
4123    ///Property: Status
4124    #[serde(skip_serializing_if = "Option::is_none")]
4125    pub status: Option<Vec<String>>,
4126    ///Property: Summary
4127    #[serde(skip_serializing_if = "Option::is_none")]
4128    pub summary: Option<Vec<String>>,
4129}
4130impl Employment {
4131    /// Create a new entity with the given ID
4132    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
4133    pub fn new(id: impl Into<String>) -> Self {
4134        Self {
4135            id: id.into(),
4136            schema: "Employment".to_string(),
4137            aleph_url: None,
4138            date: None,
4139            description: None,
4140            employee: Vec::new(),
4141            employer: Vec::new(),
4142            end_date: None,
4143            index_text: None,
4144            modified_at: None,
4145            names_mentioned: None,
4146            proof: None,
4147            publisher: None,
4148            publisher_url: None,
4149            record_id: None,
4150            retrieved_at: None,
4151            role: None,
4152            source_url: None,
4153            start_date: None,
4154            status: None,
4155            summary: None,
4156        }
4157    }
4158    /// Get the schema name
4159    pub fn schema_name() -> &'static str {
4160        "Employment"
4161    }
4162}
4163///FTM Schema: Event
4164#[derive(Debug, Clone, Serialize, Deserialize)]
4165#[cfg_attr(feature = "builder", derive(Builder))]
4166#[serde(rename_all = "camelCase")]
4167pub struct Event {
4168    pub id: String,
4169    #[cfg_attr(feature = "builder", builder(default = "Event".to_string()))]
4170    pub schema: String,
4171    ///Property: Address
4172    #[serde(skip_serializing_if = "Option::is_none")]
4173    pub address: Option<Vec<String>>,
4174    ///Property: Address
4175    #[serde(skip_serializing_if = "Option::is_none")]
4176    pub address_entity: Option<Vec<String>>,
4177    ///Property: Aleph URL
4178    #[serde(skip_serializing_if = "Option::is_none")]
4179    pub aleph_url: Option<Vec<String>>,
4180    ///Property: Alias
4181    #[serde(skip_serializing_if = "Option::is_none")]
4182    pub alias: Option<Vec<String>>,
4183    ///Property: Detected companies
4184    #[serde(skip_serializing_if = "Option::is_none")]
4185    pub companies_mentioned: Option<Vec<String>>,
4186    ///Property: Country
4187    #[serde(skip_serializing_if = "Option::is_none")]
4188    pub country: Option<Vec<String>>,
4189    ///Property: Created at
4190    #[serde(skip_serializing_if = "Option::is_none")]
4191    pub created_at: Option<Vec<String>>,
4192    ///Property: Date
4193    #[serde(skip_serializing_if = "Option::is_none")]
4194    pub date: Option<Vec<String>>,
4195    ///Property: Description
4196    #[serde(skip_serializing_if = "Option::is_none")]
4197    pub description: Option<Vec<String>>,
4198    ///Property: Detected country
4199    #[serde(skip_serializing_if = "Option::is_none")]
4200    pub detected_country: Option<Vec<String>>,
4201    ///Property: Detected language
4202    #[serde(skip_serializing_if = "Option::is_none")]
4203    pub detected_language: Option<Vec<String>>,
4204    ///Property: Detected e-mail addresses
4205    #[serde(skip_serializing_if = "Option::is_none")]
4206    pub email_mentioned: Option<Vec<String>>,
4207    ///Property: End date
4208    #[serde(skip_serializing_if = "Option::is_none")]
4209    pub end_date: Option<Vec<String>>,
4210    ///Property: Detected IBANs
4211    #[serde(skip_serializing_if = "Option::is_none")]
4212    pub iban_mentioned: Option<Vec<String>>,
4213    ///Property: Important
4214    #[serde(skip_serializing_if = "Option::is_none")]
4215    pub important: Option<Vec<String>>,
4216    ///Property: Index text
4217    #[serde(skip_serializing_if = "Option::is_none")]
4218    pub index_text: Option<Vec<String>>,
4219    ///Property: Involved
4220    #[serde(skip_serializing_if = "Option::is_none")]
4221    pub involved: Option<Vec<String>>,
4222    ///Property: Detected IP addresses
4223    #[serde(skip_serializing_if = "Option::is_none")]
4224    pub ip_mentioned: Option<Vec<String>>,
4225    ///Property: Keywords
4226    #[serde(skip_serializing_if = "Option::is_none")]
4227    pub keywords: Option<Vec<String>>,
4228    ///Property: Location
4229    #[serde(skip_serializing_if = "Option::is_none")]
4230    pub location: Option<Vec<String>>,
4231    ///Property: Detected locations
4232    #[serde(skip_serializing_if = "Option::is_none")]
4233    pub location_mentioned: Option<Vec<String>>,
4234    ///Property: Modified on
4235    #[serde(skip_serializing_if = "Option::is_none")]
4236    pub modified_at: Option<Vec<String>>,
4237    ///Property: Name
4238    #[serde(default)]
4239    pub name: Vec<String>,
4240    ///Property: Detected names
4241    #[serde(skip_serializing_if = "Option::is_none")]
4242    pub names_mentioned: Option<Vec<String>>,
4243    ///Property: Notes
4244    #[serde(skip_serializing_if = "Option::is_none")]
4245    pub notes: Option<Vec<String>>,
4246    ///Property: Organizer
4247    #[serde(skip_serializing_if = "Option::is_none")]
4248    pub organizer: Option<Vec<String>>,
4249    ///Property: Detected people
4250    #[serde(skip_serializing_if = "Option::is_none")]
4251    pub people_mentioned: Option<Vec<String>>,
4252    ///Property: Detected phones
4253    #[serde(skip_serializing_if = "Option::is_none")]
4254    pub phone_mentioned: Option<Vec<String>>,
4255    ///Property: Previous name
4256    #[serde(skip_serializing_if = "Option::is_none")]
4257    pub previous_name: Option<Vec<String>>,
4258    ///Property: Program
4259    #[serde(skip_serializing_if = "Option::is_none")]
4260    pub program: Option<Vec<String>>,
4261    ///Property: Program ID
4262    #[serde(skip_serializing_if = "Option::is_none")]
4263    pub program_id: Option<Vec<String>>,
4264    ///Property: Source document
4265    #[serde(skip_serializing_if = "Option::is_none")]
4266    pub proof: Option<Vec<String>>,
4267    ///Property: Publishing source
4268    #[serde(skip_serializing_if = "Option::is_none")]
4269    pub publisher: Option<Vec<String>>,
4270    ///Property: Publishing source URL
4271    #[serde(skip_serializing_if = "Option::is_none")]
4272    pub publisher_url: Option<Vec<String>>,
4273    ///Property: Record ID
4274    #[serde(skip_serializing_if = "Option::is_none")]
4275    pub record_id: Option<Vec<String>>,
4276    ///Property: Retrieved on
4277    #[serde(skip_serializing_if = "Option::is_none")]
4278    pub retrieved_at: Option<Vec<String>>,
4279    ///Property: Source link
4280    #[serde(skip_serializing_if = "Option::is_none")]
4281    pub source_url: Option<Vec<String>>,
4282    ///Property: Start date
4283    #[serde(skip_serializing_if = "Option::is_none")]
4284    pub start_date: Option<Vec<String>>,
4285    ///Property: Summary
4286    #[serde(skip_serializing_if = "Option::is_none")]
4287    pub summary: Option<Vec<String>>,
4288    ///Property: Topics
4289    #[serde(skip_serializing_if = "Option::is_none")]
4290    pub topics: Option<Vec<String>>,
4291    ///Property: Weak alias
4292    #[serde(skip_serializing_if = "Option::is_none")]
4293    pub weak_alias: Option<Vec<String>>,
4294    ///Property: Wikidata ID
4295    #[serde(skip_serializing_if = "Option::is_none")]
4296    pub wikidata_id: Option<Vec<String>>,
4297    ///Property: Wikipedia Article
4298    #[serde(skip_serializing_if = "Option::is_none")]
4299    pub wikipedia_url: Option<Vec<String>>,
4300}
4301impl Event {
4302    /// Create a new entity with the given ID
4303    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
4304    pub fn new(id: impl Into<String>) -> Self {
4305        Self {
4306            id: id.into(),
4307            schema: "Event".to_string(),
4308            address: None,
4309            address_entity: None,
4310            aleph_url: None,
4311            alias: None,
4312            companies_mentioned: None,
4313            country: None,
4314            created_at: None,
4315            date: None,
4316            description: None,
4317            detected_country: None,
4318            detected_language: None,
4319            email_mentioned: None,
4320            end_date: None,
4321            iban_mentioned: None,
4322            important: None,
4323            index_text: None,
4324            involved: None,
4325            ip_mentioned: None,
4326            keywords: None,
4327            location: None,
4328            location_mentioned: None,
4329            modified_at: None,
4330            name: Vec::new(),
4331            names_mentioned: None,
4332            notes: None,
4333            organizer: None,
4334            people_mentioned: None,
4335            phone_mentioned: None,
4336            previous_name: None,
4337            program: None,
4338            program_id: None,
4339            proof: None,
4340            publisher: None,
4341            publisher_url: None,
4342            record_id: None,
4343            retrieved_at: None,
4344            source_url: None,
4345            start_date: None,
4346            summary: None,
4347            topics: None,
4348            weak_alias: None,
4349            wikidata_id: None,
4350            wikipedia_url: None,
4351        }
4352    }
4353    /// Get the schema name
4354    pub fn schema_name() -> &'static str {
4355        "Event"
4356    }
4357}
4358///FTM Schema: Family
4359#[derive(Debug, Clone, Serialize, Deserialize)]
4360#[cfg_attr(feature = "builder", derive(Builder))]
4361#[serde(rename_all = "camelCase")]
4362pub struct Family {
4363    pub id: String,
4364    #[cfg_attr(feature = "builder", builder(default = "Family".to_string()))]
4365    pub schema: String,
4366    ///Property: Aleph URL
4367    #[serde(skip_serializing_if = "Option::is_none")]
4368    pub aleph_url: Option<Vec<String>>,
4369    ///Property: Date
4370    #[serde(skip_serializing_if = "Option::is_none")]
4371    pub date: Option<Vec<String>>,
4372    ///Property: Description
4373    #[serde(skip_serializing_if = "Option::is_none")]
4374    pub description: Option<Vec<String>>,
4375    ///Property: End date
4376    #[serde(skip_serializing_if = "Option::is_none")]
4377    pub end_date: Option<Vec<String>>,
4378    ///Property: Index text
4379    #[serde(skip_serializing_if = "Option::is_none")]
4380    pub index_text: Option<Vec<String>>,
4381    ///Property: Modified on
4382    #[serde(skip_serializing_if = "Option::is_none")]
4383    pub modified_at: Option<Vec<String>>,
4384    ///Property: Detected names
4385    #[serde(skip_serializing_if = "Option::is_none")]
4386    pub names_mentioned: Option<Vec<String>>,
4387    ///Property: Person
4388    #[serde(default)]
4389    pub person: Vec<String>,
4390    ///Property: Source document
4391    #[serde(skip_serializing_if = "Option::is_none")]
4392    pub proof: Option<Vec<String>>,
4393    ///Property: Publishing source
4394    #[serde(skip_serializing_if = "Option::is_none")]
4395    pub publisher: Option<Vec<String>>,
4396    ///Property: Publishing source URL
4397    #[serde(skip_serializing_if = "Option::is_none")]
4398    pub publisher_url: Option<Vec<String>>,
4399    ///Property: Record ID
4400    #[serde(skip_serializing_if = "Option::is_none")]
4401    pub record_id: Option<Vec<String>>,
4402    ///Property: Relationship
4403    #[serde(skip_serializing_if = "Option::is_none")]
4404    pub relationship: Option<Vec<String>>,
4405    ///Property: Relative
4406    #[serde(default)]
4407    pub relative: Vec<String>,
4408    ///Property: Retrieved on
4409    #[serde(skip_serializing_if = "Option::is_none")]
4410    pub retrieved_at: Option<Vec<String>>,
4411    ///Property: Source link
4412    #[serde(skip_serializing_if = "Option::is_none")]
4413    pub source_url: Option<Vec<String>>,
4414    ///Property: Start date
4415    #[serde(skip_serializing_if = "Option::is_none")]
4416    pub start_date: Option<Vec<String>>,
4417    ///Property: Summary
4418    #[serde(skip_serializing_if = "Option::is_none")]
4419    pub summary: Option<Vec<String>>,
4420}
4421impl Family {
4422    /// Create a new entity with the given ID
4423    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
4424    pub fn new(id: impl Into<String>) -> Self {
4425        Self {
4426            id: id.into(),
4427            schema: "Family".to_string(),
4428            aleph_url: None,
4429            date: None,
4430            description: None,
4431            end_date: None,
4432            index_text: None,
4433            modified_at: None,
4434            names_mentioned: None,
4435            person: Vec::new(),
4436            proof: None,
4437            publisher: None,
4438            publisher_url: None,
4439            record_id: None,
4440            relationship: None,
4441            relative: Vec::new(),
4442            retrieved_at: None,
4443            source_url: None,
4444            start_date: None,
4445            summary: None,
4446        }
4447    }
4448    /// Get the schema name
4449    pub fn schema_name() -> &'static str {
4450        "Family"
4451    }
4452}
4453///FTM Schema: Folder
4454#[derive(Debug, Clone, Serialize, Deserialize)]
4455#[cfg_attr(feature = "builder", derive(Builder))]
4456#[serde(rename_all = "camelCase")]
4457pub struct Folder {
4458    pub id: String,
4459    #[cfg_attr(feature = "builder", builder(default = "Folder".to_string()))]
4460    pub schema: String,
4461    ///Property: Address
4462    #[serde(skip_serializing_if = "Option::is_none")]
4463    pub address: Option<Vec<String>>,
4464    ///Property: Address
4465    #[serde(skip_serializing_if = "Option::is_none")]
4466    pub address_entity: Option<Vec<String>>,
4467    ///Property: Aleph URL
4468    #[serde(skip_serializing_if = "Option::is_none")]
4469    pub aleph_url: Option<Vec<String>>,
4470    ///Property: Alias
4471    #[serde(skip_serializing_if = "Option::is_none")]
4472    pub alias: Option<Vec<String>>,
4473    ///Property: Ancestors
4474    #[serde(skip_serializing_if = "Option::is_none")]
4475    pub ancestors: Option<Vec<String>>,
4476    ///Property: Author
4477    #[serde(skip_serializing_if = "Option::is_none")]
4478    pub author: Option<Vec<String>>,
4479    ///Property: Authored on
4480    #[serde(skip_serializing_if = "Option::is_none")]
4481    pub authored_at: Option<Vec<String>>,
4482    ///Property: Text
4483    #[serde(skip_serializing_if = "Option::is_none")]
4484    pub body_text: Option<Vec<String>>,
4485    ///Property: Detected companies
4486    #[serde(skip_serializing_if = "Option::is_none")]
4487    pub companies_mentioned: Option<Vec<String>>,
4488    ///Property: Checksum
4489    #[serde(skip_serializing_if = "Option::is_none")]
4490    pub content_hash: Option<Vec<String>>,
4491    ///Property: Country
4492    #[serde(skip_serializing_if = "Option::is_none")]
4493    pub country: Option<Vec<String>>,
4494    ///Property: Crawler
4495    #[serde(skip_serializing_if = "Option::is_none")]
4496    pub crawler: Option<Vec<String>>,
4497    ///Property: Created at
4498    #[serde(skip_serializing_if = "Option::is_none")]
4499    pub created_at: Option<Vec<String>>,
4500    ///Property: Date
4501    #[serde(skip_serializing_if = "Option::is_none")]
4502    pub date: Option<Vec<String>>,
4503    ///Property: Description
4504    #[serde(skip_serializing_if = "Option::is_none")]
4505    pub description: Option<Vec<String>>,
4506    ///Property: Detected country
4507    #[serde(skip_serializing_if = "Option::is_none")]
4508    pub detected_country: Option<Vec<String>>,
4509    ///Property: Detected language
4510    #[serde(skip_serializing_if = "Option::is_none")]
4511    pub detected_language: Option<Vec<String>>,
4512    ///Property: Detected e-mail addresses
4513    #[serde(skip_serializing_if = "Option::is_none")]
4514    pub email_mentioned: Option<Vec<String>>,
4515    ///Property: File encoding
4516    #[serde(skip_serializing_if = "Option::is_none")]
4517    pub encoding: Option<Vec<String>>,
4518    ///Property: File extension
4519    #[serde(skip_serializing_if = "Option::is_none")]
4520    pub extension: Option<Vec<String>>,
4521    ///Property: File name
4522    #[serde(default)]
4523    pub file_name: Vec<String>,
4524    ///Property: File size
4525    #[serde(
4526        skip_serializing_if = "Option::is_none",
4527        deserialize_with = "deserialize_opt_f64_vec",
4528        default
4529    )]
4530    pub file_size: Option<Vec<f64>>,
4531    ///Property: Generator
4532    #[serde(skip_serializing_if = "Option::is_none")]
4533    pub generator: Option<Vec<String>>,
4534    ///Property: Detected IBANs
4535    #[serde(skip_serializing_if = "Option::is_none")]
4536    pub iban_mentioned: Option<Vec<String>>,
4537    ///Property: Index text
4538    #[serde(skip_serializing_if = "Option::is_none")]
4539    pub index_text: Option<Vec<String>>,
4540    ///Property: Detected IP addresses
4541    #[serde(skip_serializing_if = "Option::is_none")]
4542    pub ip_mentioned: Option<Vec<String>>,
4543    ///Property: Keywords
4544    #[serde(skip_serializing_if = "Option::is_none")]
4545    pub keywords: Option<Vec<String>>,
4546    ///Property: Language
4547    #[serde(skip_serializing_if = "Option::is_none")]
4548    pub language: Option<Vec<String>>,
4549    ///Property: Detected locations
4550    #[serde(skip_serializing_if = "Option::is_none")]
4551    pub location_mentioned: Option<Vec<String>>,
4552    ///Property: Message ID
4553    #[serde(skip_serializing_if = "Option::is_none")]
4554    pub message_id: Option<Vec<String>>,
4555    ///Property: MIME type
4556    #[serde(skip_serializing_if = "Option::is_none")]
4557    pub mime_type: Option<Vec<String>>,
4558    ///Property: Modified on
4559    #[serde(skip_serializing_if = "Option::is_none")]
4560    pub modified_at: Option<Vec<String>>,
4561    ///Property: Name
4562    #[serde(default)]
4563    pub name: Vec<String>,
4564    ///Property: Detected names
4565    #[serde(skip_serializing_if = "Option::is_none")]
4566    pub names_mentioned: Option<Vec<String>>,
4567    ///Property: Notes
4568    #[serde(skip_serializing_if = "Option::is_none")]
4569    pub notes: Option<Vec<String>>,
4570    ///Property: Folder
4571    #[serde(skip_serializing_if = "Option::is_none")]
4572    pub parent: Option<Vec<String>>,
4573    ///Property: Detected people
4574    #[serde(skip_serializing_if = "Option::is_none")]
4575    pub people_mentioned: Option<Vec<String>>,
4576    ///Property: Detected phones
4577    #[serde(skip_serializing_if = "Option::is_none")]
4578    pub phone_mentioned: Option<Vec<String>>,
4579    ///Property: Previous name
4580    #[serde(skip_serializing_if = "Option::is_none")]
4581    pub previous_name: Option<Vec<String>>,
4582    ///Property: Processed at
4583    #[serde(skip_serializing_if = "Option::is_none")]
4584    pub processed_at: Option<Vec<String>>,
4585    ///Property: Processing agent
4586    #[serde(skip_serializing_if = "Option::is_none")]
4587    pub processing_agent: Option<Vec<String>>,
4588    ///Property: Processing error
4589    #[serde(skip_serializing_if = "Option::is_none")]
4590    pub processing_error: Option<Vec<String>>,
4591    ///Property: Processing status
4592    #[serde(skip_serializing_if = "Option::is_none")]
4593    pub processing_status: Option<Vec<String>>,
4594    ///Property: Program
4595    #[serde(skip_serializing_if = "Option::is_none")]
4596    pub program: Option<Vec<String>>,
4597    ///Property: Program ID
4598    #[serde(skip_serializing_if = "Option::is_none")]
4599    pub program_id: Option<Vec<String>>,
4600    ///Property: Source document
4601    #[serde(skip_serializing_if = "Option::is_none")]
4602    pub proof: Option<Vec<String>>,
4603    ///Property: Published on
4604    #[serde(skip_serializing_if = "Option::is_none")]
4605    pub published_at: Option<Vec<String>>,
4606    ///Property: Publishing source
4607    #[serde(skip_serializing_if = "Option::is_none")]
4608    pub publisher: Option<Vec<String>>,
4609    ///Property: Publishing source URL
4610    #[serde(skip_serializing_if = "Option::is_none")]
4611    pub publisher_url: Option<Vec<String>>,
4612    ///Property: Retrieved on
4613    #[serde(skip_serializing_if = "Option::is_none")]
4614    pub retrieved_at: Option<Vec<String>>,
4615    ///Property: Source link
4616    #[serde(skip_serializing_if = "Option::is_none")]
4617    pub source_url: Option<Vec<String>>,
4618    ///Property: Summary
4619    #[serde(skip_serializing_if = "Option::is_none")]
4620    pub summary: Option<Vec<String>>,
4621    ///Property: Title
4622    #[serde(skip_serializing_if = "Option::is_none")]
4623    pub title: Option<Vec<String>>,
4624    ///Property: Topics
4625    #[serde(skip_serializing_if = "Option::is_none")]
4626    pub topics: Option<Vec<String>>,
4627    ///Property: The language of the translated text
4628    #[serde(skip_serializing_if = "Option::is_none")]
4629    pub translated_language: Option<Vec<String>>,
4630    ///Property: Translated version of the body text
4631    #[serde(skip_serializing_if = "Option::is_none")]
4632    pub translated_text: Option<Vec<String>>,
4633    ///Property: Weak alias
4634    #[serde(skip_serializing_if = "Option::is_none")]
4635    pub weak_alias: Option<Vec<String>>,
4636    ///Property: Wikidata ID
4637    #[serde(skip_serializing_if = "Option::is_none")]
4638    pub wikidata_id: Option<Vec<String>>,
4639    ///Property: Wikipedia Article
4640    #[serde(skip_serializing_if = "Option::is_none")]
4641    pub wikipedia_url: Option<Vec<String>>,
4642}
4643impl Folder {
4644    /// Create a new entity with the given ID
4645    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
4646    pub fn new(id: impl Into<String>) -> Self {
4647        Self {
4648            id: id.into(),
4649            schema: "Folder".to_string(),
4650            address: None,
4651            address_entity: None,
4652            aleph_url: None,
4653            alias: None,
4654            ancestors: None,
4655            author: None,
4656            authored_at: None,
4657            body_text: None,
4658            companies_mentioned: None,
4659            content_hash: None,
4660            country: None,
4661            crawler: None,
4662            created_at: None,
4663            date: None,
4664            description: None,
4665            detected_country: None,
4666            detected_language: None,
4667            email_mentioned: None,
4668            encoding: None,
4669            extension: None,
4670            file_name: Vec::new(),
4671            file_size: None,
4672            generator: None,
4673            iban_mentioned: None,
4674            index_text: None,
4675            ip_mentioned: None,
4676            keywords: None,
4677            language: None,
4678            location_mentioned: None,
4679            message_id: None,
4680            mime_type: None,
4681            modified_at: None,
4682            name: Vec::new(),
4683            names_mentioned: None,
4684            notes: None,
4685            parent: None,
4686            people_mentioned: None,
4687            phone_mentioned: None,
4688            previous_name: None,
4689            processed_at: None,
4690            processing_agent: None,
4691            processing_error: None,
4692            processing_status: None,
4693            program: None,
4694            program_id: None,
4695            proof: None,
4696            published_at: None,
4697            publisher: None,
4698            publisher_url: None,
4699            retrieved_at: None,
4700            source_url: None,
4701            summary: None,
4702            title: None,
4703            topics: None,
4704            translated_language: None,
4705            translated_text: None,
4706            weak_alias: None,
4707            wikidata_id: None,
4708            wikipedia_url: None,
4709        }
4710    }
4711    /// Get the schema name
4712    pub fn schema_name() -> &'static str {
4713        "Folder"
4714    }
4715}
4716///FTM Schema: Web page
4717#[derive(Debug, Clone, Serialize, Deserialize)]
4718#[cfg_attr(feature = "builder", derive(Builder))]
4719#[serde(rename_all = "camelCase")]
4720pub struct HyperText {
4721    pub id: String,
4722    #[cfg_attr(feature = "builder", builder(default = "HyperText".to_string()))]
4723    pub schema: String,
4724    ///Property: Address
4725    #[serde(skip_serializing_if = "Option::is_none")]
4726    pub address: Option<Vec<String>>,
4727    ///Property: Address
4728    #[serde(skip_serializing_if = "Option::is_none")]
4729    pub address_entity: Option<Vec<String>>,
4730    ///Property: Aleph URL
4731    #[serde(skip_serializing_if = "Option::is_none")]
4732    pub aleph_url: Option<Vec<String>>,
4733    ///Property: Alias
4734    #[serde(skip_serializing_if = "Option::is_none")]
4735    pub alias: Option<Vec<String>>,
4736    ///Property: Ancestors
4737    #[serde(skip_serializing_if = "Option::is_none")]
4738    pub ancestors: Option<Vec<String>>,
4739    ///Property: Author
4740    #[serde(skip_serializing_if = "Option::is_none")]
4741    pub author: Option<Vec<String>>,
4742    ///Property: Authored on
4743    #[serde(skip_serializing_if = "Option::is_none")]
4744    pub authored_at: Option<Vec<String>>,
4745    ///Property: HTML
4746    #[serde(skip_serializing_if = "Option::is_none")]
4747    pub body_html: Option<Vec<String>>,
4748    ///Property: Text
4749    #[serde(skip_serializing_if = "Option::is_none")]
4750    pub body_text: Option<Vec<String>>,
4751    ///Property: Detected companies
4752    #[serde(skip_serializing_if = "Option::is_none")]
4753    pub companies_mentioned: Option<Vec<String>>,
4754    ///Property: Checksum
4755    #[serde(skip_serializing_if = "Option::is_none")]
4756    pub content_hash: Option<Vec<String>>,
4757    ///Property: Country
4758    #[serde(skip_serializing_if = "Option::is_none")]
4759    pub country: Option<Vec<String>>,
4760    ///Property: Crawler
4761    #[serde(skip_serializing_if = "Option::is_none")]
4762    pub crawler: Option<Vec<String>>,
4763    ///Property: Created at
4764    #[serde(skip_serializing_if = "Option::is_none")]
4765    pub created_at: Option<Vec<String>>,
4766    ///Property: Date
4767    #[serde(skip_serializing_if = "Option::is_none")]
4768    pub date: Option<Vec<String>>,
4769    ///Property: Description
4770    #[serde(skip_serializing_if = "Option::is_none")]
4771    pub description: Option<Vec<String>>,
4772    ///Property: Detected country
4773    #[serde(skip_serializing_if = "Option::is_none")]
4774    pub detected_country: Option<Vec<String>>,
4775    ///Property: Detected language
4776    #[serde(skip_serializing_if = "Option::is_none")]
4777    pub detected_language: Option<Vec<String>>,
4778    ///Property: Detected e-mail addresses
4779    #[serde(skip_serializing_if = "Option::is_none")]
4780    pub email_mentioned: Option<Vec<String>>,
4781    ///Property: File encoding
4782    #[serde(skip_serializing_if = "Option::is_none")]
4783    pub encoding: Option<Vec<String>>,
4784    ///Property: File extension
4785    #[serde(skip_serializing_if = "Option::is_none")]
4786    pub extension: Option<Vec<String>>,
4787    ///Property: File name
4788    #[serde(default)]
4789    pub file_name: Vec<String>,
4790    ///Property: File size
4791    #[serde(
4792        skip_serializing_if = "Option::is_none",
4793        deserialize_with = "deserialize_opt_f64_vec",
4794        default
4795    )]
4796    pub file_size: Option<Vec<f64>>,
4797    ///Property: Generator
4798    #[serde(skip_serializing_if = "Option::is_none")]
4799    pub generator: Option<Vec<String>>,
4800    ///Property: Detected IBANs
4801    #[serde(skip_serializing_if = "Option::is_none")]
4802    pub iban_mentioned: Option<Vec<String>>,
4803    ///Property: Index text
4804    #[serde(skip_serializing_if = "Option::is_none")]
4805    pub index_text: Option<Vec<String>>,
4806    ///Property: Detected IP addresses
4807    #[serde(skip_serializing_if = "Option::is_none")]
4808    pub ip_mentioned: Option<Vec<String>>,
4809    ///Property: Keywords
4810    #[serde(skip_serializing_if = "Option::is_none")]
4811    pub keywords: Option<Vec<String>>,
4812    ///Property: Language
4813    #[serde(skip_serializing_if = "Option::is_none")]
4814    pub language: Option<Vec<String>>,
4815    ///Property: Detected locations
4816    #[serde(skip_serializing_if = "Option::is_none")]
4817    pub location_mentioned: Option<Vec<String>>,
4818    ///Property: Message ID
4819    #[serde(skip_serializing_if = "Option::is_none")]
4820    pub message_id: Option<Vec<String>>,
4821    ///Property: MIME type
4822    #[serde(skip_serializing_if = "Option::is_none")]
4823    pub mime_type: Option<Vec<String>>,
4824    ///Property: Modified on
4825    #[serde(skip_serializing_if = "Option::is_none")]
4826    pub modified_at: Option<Vec<String>>,
4827    ///Property: Name
4828    #[serde(default)]
4829    pub name: Vec<String>,
4830    ///Property: Detected names
4831    #[serde(skip_serializing_if = "Option::is_none")]
4832    pub names_mentioned: Option<Vec<String>>,
4833    ///Property: Notes
4834    #[serde(skip_serializing_if = "Option::is_none")]
4835    pub notes: Option<Vec<String>>,
4836    ///Property: Folder
4837    #[serde(skip_serializing_if = "Option::is_none")]
4838    pub parent: Option<Vec<String>>,
4839    ///Property: Detected people
4840    #[serde(skip_serializing_if = "Option::is_none")]
4841    pub people_mentioned: Option<Vec<String>>,
4842    ///Property: Detected phones
4843    #[serde(skip_serializing_if = "Option::is_none")]
4844    pub phone_mentioned: Option<Vec<String>>,
4845    ///Property: Previous name
4846    #[serde(skip_serializing_if = "Option::is_none")]
4847    pub previous_name: Option<Vec<String>>,
4848    ///Property: Processed at
4849    #[serde(skip_serializing_if = "Option::is_none")]
4850    pub processed_at: Option<Vec<String>>,
4851    ///Property: Processing agent
4852    #[serde(skip_serializing_if = "Option::is_none")]
4853    pub processing_agent: Option<Vec<String>>,
4854    ///Property: Processing error
4855    #[serde(skip_serializing_if = "Option::is_none")]
4856    pub processing_error: Option<Vec<String>>,
4857    ///Property: Processing status
4858    #[serde(skip_serializing_if = "Option::is_none")]
4859    pub processing_status: Option<Vec<String>>,
4860    ///Property: Program
4861    #[serde(skip_serializing_if = "Option::is_none")]
4862    pub program: Option<Vec<String>>,
4863    ///Property: Program ID
4864    #[serde(skip_serializing_if = "Option::is_none")]
4865    pub program_id: Option<Vec<String>>,
4866    ///Property: Source document
4867    #[serde(skip_serializing_if = "Option::is_none")]
4868    pub proof: Option<Vec<String>>,
4869    ///Property: Published on
4870    #[serde(skip_serializing_if = "Option::is_none")]
4871    pub published_at: Option<Vec<String>>,
4872    ///Property: Publishing source
4873    #[serde(skip_serializing_if = "Option::is_none")]
4874    pub publisher: Option<Vec<String>>,
4875    ///Property: Publishing source URL
4876    #[serde(skip_serializing_if = "Option::is_none")]
4877    pub publisher_url: Option<Vec<String>>,
4878    ///Property: Retrieved on
4879    #[serde(skip_serializing_if = "Option::is_none")]
4880    pub retrieved_at: Option<Vec<String>>,
4881    ///Property: Source link
4882    #[serde(skip_serializing_if = "Option::is_none")]
4883    pub source_url: Option<Vec<String>>,
4884    ///Property: Summary
4885    #[serde(skip_serializing_if = "Option::is_none")]
4886    pub summary: Option<Vec<String>>,
4887    ///Property: Title
4888    #[serde(skip_serializing_if = "Option::is_none")]
4889    pub title: Option<Vec<String>>,
4890    ///Property: Topics
4891    #[serde(skip_serializing_if = "Option::is_none")]
4892    pub topics: Option<Vec<String>>,
4893    ///Property: The language of the translated text
4894    #[serde(skip_serializing_if = "Option::is_none")]
4895    pub translated_language: Option<Vec<String>>,
4896    ///Property: Translated version of the body text
4897    #[serde(skip_serializing_if = "Option::is_none")]
4898    pub translated_text: Option<Vec<String>>,
4899    ///Property: Weak alias
4900    #[serde(skip_serializing_if = "Option::is_none")]
4901    pub weak_alias: Option<Vec<String>>,
4902    ///Property: Wikidata ID
4903    #[serde(skip_serializing_if = "Option::is_none")]
4904    pub wikidata_id: Option<Vec<String>>,
4905    ///Property: Wikipedia Article
4906    #[serde(skip_serializing_if = "Option::is_none")]
4907    pub wikipedia_url: Option<Vec<String>>,
4908}
4909impl HyperText {
4910    /// Create a new entity with the given ID
4911    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
4912    pub fn new(id: impl Into<String>) -> Self {
4913        Self {
4914            id: id.into(),
4915            schema: "HyperText".to_string(),
4916            address: None,
4917            address_entity: None,
4918            aleph_url: None,
4919            alias: None,
4920            ancestors: None,
4921            author: None,
4922            authored_at: None,
4923            body_html: None,
4924            body_text: None,
4925            companies_mentioned: None,
4926            content_hash: None,
4927            country: None,
4928            crawler: None,
4929            created_at: None,
4930            date: None,
4931            description: None,
4932            detected_country: None,
4933            detected_language: None,
4934            email_mentioned: None,
4935            encoding: None,
4936            extension: None,
4937            file_name: Vec::new(),
4938            file_size: None,
4939            generator: None,
4940            iban_mentioned: None,
4941            index_text: None,
4942            ip_mentioned: None,
4943            keywords: None,
4944            language: None,
4945            location_mentioned: None,
4946            message_id: None,
4947            mime_type: None,
4948            modified_at: None,
4949            name: Vec::new(),
4950            names_mentioned: None,
4951            notes: None,
4952            parent: None,
4953            people_mentioned: None,
4954            phone_mentioned: None,
4955            previous_name: None,
4956            processed_at: None,
4957            processing_agent: None,
4958            processing_error: None,
4959            processing_status: None,
4960            program: None,
4961            program_id: None,
4962            proof: None,
4963            published_at: None,
4964            publisher: None,
4965            publisher_url: None,
4966            retrieved_at: None,
4967            source_url: None,
4968            summary: None,
4969            title: None,
4970            topics: None,
4971            translated_language: None,
4972            translated_text: None,
4973            weak_alias: None,
4974            wikidata_id: None,
4975            wikipedia_url: None,
4976        }
4977    }
4978    /// Get the schema name
4979    pub fn schema_name() -> &'static str {
4980        "HyperText"
4981    }
4982}
4983///FTM Schema: Identification
4984#[derive(Debug, Clone, Serialize, Deserialize)]
4985#[cfg_attr(feature = "builder", derive(Builder))]
4986#[serde(rename_all = "camelCase")]
4987pub struct Identification {
4988    pub id: String,
4989    #[cfg_attr(feature = "builder", builder(default = "Identification".to_string()))]
4990    pub schema: String,
4991    ///Property: Aleph URL
4992    #[serde(skip_serializing_if = "Option::is_none")]
4993    pub aleph_url: Option<Vec<String>>,
4994    ///Property: Authority
4995    #[serde(skip_serializing_if = "Option::is_none")]
4996    pub authority: Option<Vec<String>>,
4997    ///Property: Country
4998    #[serde(skip_serializing_if = "Option::is_none")]
4999    pub country: Option<Vec<String>>,
5000    ///Property: Date
5001    #[serde(skip_serializing_if = "Option::is_none")]
5002    pub date: Option<Vec<String>>,
5003    ///Property: Description
5004    #[serde(skip_serializing_if = "Option::is_none")]
5005    pub description: Option<Vec<String>>,
5006    ///Property: End date
5007    #[serde(skip_serializing_if = "Option::is_none")]
5008    pub end_date: Option<Vec<String>>,
5009    ///Property: Identification holder
5010    #[serde(default)]
5011    pub holder: Vec<String>,
5012    ///Property: Index text
5013    #[serde(skip_serializing_if = "Option::is_none")]
5014    pub index_text: Option<Vec<String>>,
5015    ///Property: Modified on
5016    #[serde(skip_serializing_if = "Option::is_none")]
5017    pub modified_at: Option<Vec<String>>,
5018    ///Property: Detected names
5019    #[serde(skip_serializing_if = "Option::is_none")]
5020    pub names_mentioned: Option<Vec<String>>,
5021    ///Property: Document number
5022    #[serde(default)]
5023    pub number: Vec<String>,
5024    ///Property: Source document
5025    #[serde(skip_serializing_if = "Option::is_none")]
5026    pub proof: Option<Vec<String>>,
5027    ///Property: Publishing source
5028    #[serde(skip_serializing_if = "Option::is_none")]
5029    pub publisher: Option<Vec<String>>,
5030    ///Property: Publishing source URL
5031    #[serde(skip_serializing_if = "Option::is_none")]
5032    pub publisher_url: Option<Vec<String>>,
5033    ///Property: Record ID
5034    #[serde(skip_serializing_if = "Option::is_none")]
5035    pub record_id: Option<Vec<String>>,
5036    ///Property: Retrieved on
5037    #[serde(skip_serializing_if = "Option::is_none")]
5038    pub retrieved_at: Option<Vec<String>>,
5039    ///Property: Source link
5040    #[serde(skip_serializing_if = "Option::is_none")]
5041    pub source_url: Option<Vec<String>>,
5042    ///Property: Start date
5043    #[serde(skip_serializing_if = "Option::is_none")]
5044    pub start_date: Option<Vec<String>>,
5045    ///Property: Summary
5046    #[serde(skip_serializing_if = "Option::is_none")]
5047    pub summary: Option<Vec<String>>,
5048    ///Property: Type
5049    #[serde(skip_serializing_if = "Option::is_none")]
5050    pub type_: Option<Vec<String>>,
5051}
5052impl Identification {
5053    /// Create a new entity with the given ID
5054    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
5055    pub fn new(id: impl Into<String>) -> Self {
5056        Self {
5057            id: id.into(),
5058            schema: "Identification".to_string(),
5059            aleph_url: None,
5060            authority: None,
5061            country: None,
5062            date: None,
5063            description: None,
5064            end_date: None,
5065            holder: Vec::new(),
5066            index_text: None,
5067            modified_at: None,
5068            names_mentioned: None,
5069            number: Vec::new(),
5070            proof: None,
5071            publisher: None,
5072            publisher_url: None,
5073            record_id: None,
5074            retrieved_at: None,
5075            source_url: None,
5076            start_date: None,
5077            summary: None,
5078            type_: None,
5079        }
5080    }
5081    /// Get the schema name
5082    pub fn schema_name() -> &'static str {
5083        "Identification"
5084    }
5085}
5086///FTM Schema: Image
5087#[derive(Debug, Clone, Serialize, Deserialize)]
5088#[cfg_attr(feature = "builder", derive(Builder))]
5089#[serde(rename_all = "camelCase")]
5090pub struct Image {
5091    pub id: String,
5092    #[cfg_attr(feature = "builder", builder(default = "Image".to_string()))]
5093    pub schema: String,
5094    ///Property: Address
5095    #[serde(skip_serializing_if = "Option::is_none")]
5096    pub address: Option<Vec<String>>,
5097    ///Property: Address
5098    #[serde(skip_serializing_if = "Option::is_none")]
5099    pub address_entity: Option<Vec<String>>,
5100    ///Property: Aleph URL
5101    #[serde(skip_serializing_if = "Option::is_none")]
5102    pub aleph_url: Option<Vec<String>>,
5103    ///Property: Alias
5104    #[serde(skip_serializing_if = "Option::is_none")]
5105    pub alias: Option<Vec<String>>,
5106    ///Property: Ancestors
5107    #[serde(skip_serializing_if = "Option::is_none")]
5108    pub ancestors: Option<Vec<String>>,
5109    ///Property: Author
5110    #[serde(skip_serializing_if = "Option::is_none")]
5111    pub author: Option<Vec<String>>,
5112    ///Property: Authored on
5113    #[serde(skip_serializing_if = "Option::is_none")]
5114    pub authored_at: Option<Vec<String>>,
5115    ///Property: Text
5116    #[serde(skip_serializing_if = "Option::is_none")]
5117    pub body_text: Option<Vec<String>>,
5118    ///Property: Detected companies
5119    #[serde(skip_serializing_if = "Option::is_none")]
5120    pub companies_mentioned: Option<Vec<String>>,
5121    ///Property: Checksum
5122    #[serde(skip_serializing_if = "Option::is_none")]
5123    pub content_hash: Option<Vec<String>>,
5124    ///Property: Country
5125    #[serde(skip_serializing_if = "Option::is_none")]
5126    pub country: Option<Vec<String>>,
5127    ///Property: Crawler
5128    #[serde(skip_serializing_if = "Option::is_none")]
5129    pub crawler: Option<Vec<String>>,
5130    ///Property: Created at
5131    #[serde(skip_serializing_if = "Option::is_none")]
5132    pub created_at: Option<Vec<String>>,
5133    ///Property: Credit
5134    #[serde(skip_serializing_if = "Option::is_none")]
5135    pub credit: Option<Vec<String>>,
5136    ///Property: Date
5137    #[serde(skip_serializing_if = "Option::is_none")]
5138    pub date: Option<Vec<String>>,
5139    ///Property: Description
5140    #[serde(skip_serializing_if = "Option::is_none")]
5141    pub description: Option<Vec<String>>,
5142    ///Property: Detected country
5143    #[serde(skip_serializing_if = "Option::is_none")]
5144    pub detected_country: Option<Vec<String>>,
5145    ///Property: Detected language
5146    #[serde(skip_serializing_if = "Option::is_none")]
5147    pub detected_language: Option<Vec<String>>,
5148    ///Property: Detected e-mail addresses
5149    #[serde(skip_serializing_if = "Option::is_none")]
5150    pub email_mentioned: Option<Vec<String>>,
5151    ///Property: File encoding
5152    #[serde(skip_serializing_if = "Option::is_none")]
5153    pub encoding: Option<Vec<String>>,
5154    ///Property: File extension
5155    #[serde(skip_serializing_if = "Option::is_none")]
5156    pub extension: Option<Vec<String>>,
5157    ///Property: File name
5158    #[serde(default)]
5159    pub file_name: Vec<String>,
5160    ///Property: File size
5161    #[serde(
5162        skip_serializing_if = "Option::is_none",
5163        deserialize_with = "deserialize_opt_f64_vec",
5164        default
5165    )]
5166    pub file_size: Option<Vec<f64>>,
5167    ///Property: Generator
5168    #[serde(skip_serializing_if = "Option::is_none")]
5169    pub generator: Option<Vec<String>>,
5170    ///Property: Detected IBANs
5171    #[serde(skip_serializing_if = "Option::is_none")]
5172    pub iban_mentioned: Option<Vec<String>>,
5173    ///Property: Index text
5174    #[serde(skip_serializing_if = "Option::is_none")]
5175    pub index_text: Option<Vec<String>>,
5176    ///Property: Detected IP addresses
5177    #[serde(skip_serializing_if = "Option::is_none")]
5178    pub ip_mentioned: Option<Vec<String>>,
5179    ///Property: Keywords
5180    #[serde(skip_serializing_if = "Option::is_none")]
5181    pub keywords: Option<Vec<String>>,
5182    ///Property: Language
5183    #[serde(skip_serializing_if = "Option::is_none")]
5184    pub language: Option<Vec<String>>,
5185    ///Property: Detected locations
5186    #[serde(skip_serializing_if = "Option::is_none")]
5187    pub location_mentioned: Option<Vec<String>>,
5188    ///Property: Message ID
5189    #[serde(skip_serializing_if = "Option::is_none")]
5190    pub message_id: Option<Vec<String>>,
5191    ///Property: MIME type
5192    #[serde(skip_serializing_if = "Option::is_none")]
5193    pub mime_type: Option<Vec<String>>,
5194    ///Property: Modified on
5195    #[serde(skip_serializing_if = "Option::is_none")]
5196    pub modified_at: Option<Vec<String>>,
5197    ///Property: Name
5198    #[serde(default)]
5199    pub name: Vec<String>,
5200    ///Property: Detected names
5201    #[serde(skip_serializing_if = "Option::is_none")]
5202    pub names_mentioned: Option<Vec<String>>,
5203    ///Property: Notes
5204    #[serde(skip_serializing_if = "Option::is_none")]
5205    pub notes: Option<Vec<String>>,
5206    ///Property: Folder
5207    #[serde(skip_serializing_if = "Option::is_none")]
5208    pub parent: Option<Vec<String>>,
5209    ///Property: Detected people
5210    #[serde(skip_serializing_if = "Option::is_none")]
5211    pub people_mentioned: Option<Vec<String>>,
5212    ///Property: Detected phones
5213    #[serde(skip_serializing_if = "Option::is_none")]
5214    pub phone_mentioned: Option<Vec<String>>,
5215    ///Property: Pictured
5216    #[serde(skip_serializing_if = "Option::is_none")]
5217    pub pictured: Option<Vec<String>>,
5218    ///Property: Previous name
5219    #[serde(skip_serializing_if = "Option::is_none")]
5220    pub previous_name: Option<Vec<String>>,
5221    ///Property: Processed at
5222    #[serde(skip_serializing_if = "Option::is_none")]
5223    pub processed_at: Option<Vec<String>>,
5224    ///Property: Processing agent
5225    #[serde(skip_serializing_if = "Option::is_none")]
5226    pub processing_agent: Option<Vec<String>>,
5227    ///Property: Processing error
5228    #[serde(skip_serializing_if = "Option::is_none")]
5229    pub processing_error: Option<Vec<String>>,
5230    ///Property: Processing status
5231    #[serde(skip_serializing_if = "Option::is_none")]
5232    pub processing_status: Option<Vec<String>>,
5233    ///Property: Program
5234    #[serde(skip_serializing_if = "Option::is_none")]
5235    pub program: Option<Vec<String>>,
5236    ///Property: Program ID
5237    #[serde(skip_serializing_if = "Option::is_none")]
5238    pub program_id: Option<Vec<String>>,
5239    ///Property: Source document
5240    #[serde(skip_serializing_if = "Option::is_none")]
5241    pub proof: Option<Vec<String>>,
5242    ///Property: Published on
5243    #[serde(skip_serializing_if = "Option::is_none")]
5244    pub published_at: Option<Vec<String>>,
5245    ///Property: Publishing source
5246    #[serde(skip_serializing_if = "Option::is_none")]
5247    pub publisher: Option<Vec<String>>,
5248    ///Property: Publishing source URL
5249    #[serde(skip_serializing_if = "Option::is_none")]
5250    pub publisher_url: Option<Vec<String>>,
5251    ///Property: Retrieved on
5252    #[serde(skip_serializing_if = "Option::is_none")]
5253    pub retrieved_at: Option<Vec<String>>,
5254    ///Property: Source link
5255    #[serde(skip_serializing_if = "Option::is_none")]
5256    pub source_url: Option<Vec<String>>,
5257    ///Property: Summary
5258    #[serde(skip_serializing_if = "Option::is_none")]
5259    pub summary: Option<Vec<String>>,
5260    ///Property: Title
5261    #[serde(skip_serializing_if = "Option::is_none")]
5262    pub title: Option<Vec<String>>,
5263    ///Property: Topics
5264    #[serde(skip_serializing_if = "Option::is_none")]
5265    pub topics: Option<Vec<String>>,
5266    ///Property: The language of the translated text
5267    #[serde(skip_serializing_if = "Option::is_none")]
5268    pub translated_language: Option<Vec<String>>,
5269    ///Property: Translated version of the body text
5270    #[serde(skip_serializing_if = "Option::is_none")]
5271    pub translated_text: Option<Vec<String>>,
5272    ///Property: Weak alias
5273    #[serde(skip_serializing_if = "Option::is_none")]
5274    pub weak_alias: Option<Vec<String>>,
5275    ///Property: Wikidata ID
5276    #[serde(skip_serializing_if = "Option::is_none")]
5277    pub wikidata_id: Option<Vec<String>>,
5278    ///Property: Wikipedia Article
5279    #[serde(skip_serializing_if = "Option::is_none")]
5280    pub wikipedia_url: Option<Vec<String>>,
5281}
5282impl Image {
5283    /// Create a new entity with the given ID
5284    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
5285    pub fn new(id: impl Into<String>) -> Self {
5286        Self {
5287            id: id.into(),
5288            schema: "Image".to_string(),
5289            address: None,
5290            address_entity: None,
5291            aleph_url: None,
5292            alias: None,
5293            ancestors: None,
5294            author: None,
5295            authored_at: None,
5296            body_text: None,
5297            companies_mentioned: None,
5298            content_hash: None,
5299            country: None,
5300            crawler: None,
5301            created_at: None,
5302            credit: None,
5303            date: None,
5304            description: None,
5305            detected_country: None,
5306            detected_language: None,
5307            email_mentioned: None,
5308            encoding: None,
5309            extension: None,
5310            file_name: Vec::new(),
5311            file_size: None,
5312            generator: None,
5313            iban_mentioned: None,
5314            index_text: None,
5315            ip_mentioned: None,
5316            keywords: None,
5317            language: None,
5318            location_mentioned: None,
5319            message_id: None,
5320            mime_type: None,
5321            modified_at: None,
5322            name: Vec::new(),
5323            names_mentioned: None,
5324            notes: None,
5325            parent: None,
5326            people_mentioned: None,
5327            phone_mentioned: None,
5328            pictured: None,
5329            previous_name: None,
5330            processed_at: None,
5331            processing_agent: None,
5332            processing_error: None,
5333            processing_status: None,
5334            program: None,
5335            program_id: None,
5336            proof: None,
5337            published_at: None,
5338            publisher: None,
5339            publisher_url: None,
5340            retrieved_at: None,
5341            source_url: None,
5342            summary: None,
5343            title: None,
5344            topics: None,
5345            translated_language: None,
5346            translated_text: None,
5347            weak_alias: None,
5348            wikidata_id: None,
5349            wikipedia_url: None,
5350        }
5351    }
5352    /// Get the schema name
5353    pub fn schema_name() -> &'static str {
5354        "Image"
5355    }
5356}
5357///FTM Schema: Legal entity
5358#[derive(Debug, Clone, Serialize, Deserialize)]
5359#[cfg_attr(feature = "builder", derive(Builder))]
5360#[serde(rename_all = "camelCase")]
5361pub struct LegalEntity {
5362    pub id: String,
5363    #[cfg_attr(feature = "builder", builder(default = "LegalEntity".to_string()))]
5364    pub schema: String,
5365    ///Property: Abbreviation
5366    #[serde(skip_serializing_if = "Option::is_none")]
5367    pub abbreviation: Option<Vec<String>>,
5368    ///Property: Address
5369    #[serde(skip_serializing_if = "Option::is_none")]
5370    pub address: Option<Vec<String>>,
5371    ///Property: Address
5372    #[serde(skip_serializing_if = "Option::is_none")]
5373    pub address_entity: Option<Vec<String>>,
5374    ///Property: Aleph URL
5375    #[serde(skip_serializing_if = "Option::is_none")]
5376    pub aleph_url: Option<Vec<String>>,
5377    ///Property: Alias
5378    #[serde(skip_serializing_if = "Option::is_none")]
5379    pub alias: Option<Vec<String>>,
5380    ///Property: BrightQuery ID
5381    #[serde(skip_serializing_if = "Option::is_none")]
5382    pub bright_query_id: Option<Vec<String>>,
5383    ///Property: BrightQuery Organization ID
5384    #[serde(skip_serializing_if = "Option::is_none")]
5385    pub bright_query_org_id: Option<Vec<String>>,
5386    ///Property: Bureau van Dijk ID
5387    #[serde(skip_serializing_if = "Option::is_none")]
5388    pub bvd_id: Option<Vec<String>>,
5389    ///Property: Classification
5390    #[serde(skip_serializing_if = "Option::is_none")]
5391    pub classification: Option<Vec<String>>,
5392    ///Property: Country
5393    #[serde(skip_serializing_if = "Option::is_none")]
5394    pub country: Option<Vec<String>>,
5395    ///Property: Created at
5396    #[serde(skip_serializing_if = "Option::is_none")]
5397    pub created_at: Option<Vec<String>>,
5398    ///Property: Description
5399    #[serde(skip_serializing_if = "Option::is_none")]
5400    pub description: Option<Vec<String>>,
5401    ///Property: Dissolution date
5402    #[serde(skip_serializing_if = "Option::is_none")]
5403    pub dissolution_date: Option<Vec<String>>,
5404    ///Property: DUNS
5405    #[serde(skip_serializing_if = "Option::is_none")]
5406    pub duns_code: Option<Vec<String>>,
5407    ///Property: E-Mail
5408    #[serde(skip_serializing_if = "Option::is_none")]
5409    pub email: Option<Vec<String>>,
5410    ///Property: ICIJ ID
5411    #[serde(skip_serializing_if = "Option::is_none")]
5412    pub icij_id: Option<Vec<String>>,
5413    ///Property: ID Number
5414    #[serde(skip_serializing_if = "Option::is_none")]
5415    pub id_number: Option<Vec<String>>,
5416    ///Property: Incorporation date
5417    #[serde(skip_serializing_if = "Option::is_none")]
5418    pub incorporation_date: Option<Vec<String>>,
5419    ///Property: Index text
5420    #[serde(skip_serializing_if = "Option::is_none")]
5421    pub index_text: Option<Vec<String>>,
5422    ///Property: INN
5423    #[serde(skip_serializing_if = "Option::is_none")]
5424    pub inn_code: Option<Vec<String>>,
5425    ///Property: Jurisdiction
5426    #[serde(skip_serializing_if = "Option::is_none")]
5427    pub jurisdiction: Option<Vec<String>>,
5428    ///Property: Keywords
5429    #[serde(skip_serializing_if = "Option::is_none")]
5430    pub keywords: Option<Vec<String>>,
5431    ///Property: Legal form
5432    #[serde(skip_serializing_if = "Option::is_none")]
5433    pub legal_form: Option<Vec<String>>,
5434    ///Property: LEI
5435    #[serde(skip_serializing_if = "Option::is_none")]
5436    pub lei_code: Option<Vec<String>>,
5437    ///Property: License Number
5438    #[serde(skip_serializing_if = "Option::is_none")]
5439    pub license_number: Option<Vec<String>>,
5440    ///Property: Country of origin
5441    #[serde(skip_serializing_if = "Option::is_none")]
5442    pub main_country: Option<Vec<String>>,
5443    ///Property: Modified on
5444    #[serde(skip_serializing_if = "Option::is_none")]
5445    pub modified_at: Option<Vec<String>>,
5446    ///Property: Name
5447    #[serde(default)]
5448    pub name: Vec<String>,
5449    ///Property: Notes
5450    #[serde(skip_serializing_if = "Option::is_none")]
5451    pub notes: Option<Vec<String>>,
5452    ///Property: NPI
5453    #[serde(skip_serializing_if = "Option::is_none")]
5454    pub npi_code: Option<Vec<String>>,
5455    ///Property: OGRN
5456    #[serde(skip_serializing_if = "Option::is_none")]
5457    pub ogrn_code: Option<Vec<String>>,
5458    ///Property: OKPO
5459    #[serde(skip_serializing_if = "Option::is_none")]
5460    pub okpo_code: Option<Vec<String>>,
5461    ///Property: OpenCorporates URL
5462    #[serde(skip_serializing_if = "Option::is_none")]
5463    pub opencorporates_url: Option<Vec<String>>,
5464    ///Property: Parent company
5465    #[serde(skip_serializing_if = "Option::is_none")]
5466    pub parent: Option<Vec<String>>,
5467    ///Property: Phone
5468    #[serde(skip_serializing_if = "Option::is_none")]
5469    pub phone: Option<Vec<String>>,
5470    ///Property: Previous name
5471    #[serde(skip_serializing_if = "Option::is_none")]
5472    pub previous_name: Option<Vec<String>>,
5473    ///Property: Program
5474    #[serde(skip_serializing_if = "Option::is_none")]
5475    pub program: Option<Vec<String>>,
5476    ///Property: Program ID
5477    #[serde(skip_serializing_if = "Option::is_none")]
5478    pub program_id: Option<Vec<String>>,
5479    ///Property: Source document
5480    #[serde(skip_serializing_if = "Option::is_none")]
5481    pub proof: Option<Vec<String>>,
5482    ///Property: Publishing source
5483    #[serde(skip_serializing_if = "Option::is_none")]
5484    pub publisher: Option<Vec<String>>,
5485    ///Property: Publishing source URL
5486    #[serde(skip_serializing_if = "Option::is_none")]
5487    pub publisher_url: Option<Vec<String>>,
5488    ///Property: Registration number
5489    #[serde(skip_serializing_if = "Option::is_none")]
5490    pub registration_number: Option<Vec<String>>,
5491    ///Property: Retrieved on
5492    #[serde(skip_serializing_if = "Option::is_none")]
5493    pub retrieved_at: Option<Vec<String>>,
5494    ///Property: Sayari Entity ID
5495    #[serde(skip_serializing_if = "Option::is_none")]
5496    pub sayari_id: Option<Vec<String>>,
5497    ///Property: Sector
5498    #[serde(skip_serializing_if = "Option::is_none")]
5499    pub sector: Option<Vec<String>>,
5500    ///Property: Source link
5501    #[serde(skip_serializing_if = "Option::is_none")]
5502    pub source_url: Option<Vec<String>>,
5503    ///Property: Status
5504    #[serde(skip_serializing_if = "Option::is_none")]
5505    pub status: Option<Vec<String>>,
5506    ///Property: Summary
5507    #[serde(skip_serializing_if = "Option::is_none")]
5508    pub summary: Option<Vec<String>>,
5509    ///Property: SWIFT/BIC
5510    #[serde(skip_serializing_if = "Option::is_none")]
5511    pub swift_bic: Option<Vec<String>>,
5512    ///Property: Tax Number
5513    #[serde(skip_serializing_if = "Option::is_none")]
5514    pub tax_number: Option<Vec<String>>,
5515    ///Property: Tax status
5516    #[serde(skip_serializing_if = "Option::is_none")]
5517    pub tax_status: Option<Vec<String>>,
5518    ///Property: Topics
5519    #[serde(skip_serializing_if = "Option::is_none")]
5520    pub topics: Option<Vec<String>>,
5521    ///Property: Unique Entity ID
5522    #[serde(skip_serializing_if = "Option::is_none")]
5523    pub unique_entity_id: Option<Vec<String>>,
5524    ///Property: USCC
5525    #[serde(skip_serializing_if = "Option::is_none")]
5526    pub usc_code: Option<Vec<String>>,
5527    ///Property: V.A.T. Identifier
5528    #[serde(skip_serializing_if = "Option::is_none")]
5529    pub vat_code: Option<Vec<String>>,
5530    ///Property: Weak alias
5531    #[serde(skip_serializing_if = "Option::is_none")]
5532    pub weak_alias: Option<Vec<String>>,
5533    ///Property: Website
5534    #[serde(skip_serializing_if = "Option::is_none")]
5535    pub website: Option<Vec<String>>,
5536    ///Property: Wikidata ID
5537    #[serde(skip_serializing_if = "Option::is_none")]
5538    pub wikidata_id: Option<Vec<String>>,
5539    ///Property: Wikipedia Article
5540    #[serde(skip_serializing_if = "Option::is_none")]
5541    pub wikipedia_url: Option<Vec<String>>,
5542}
5543impl LegalEntity {
5544    /// Create a new entity with the given ID
5545    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
5546    pub fn new(id: impl Into<String>) -> Self {
5547        Self {
5548            id: id.into(),
5549            schema: "LegalEntity".to_string(),
5550            abbreviation: None,
5551            address: None,
5552            address_entity: None,
5553            aleph_url: None,
5554            alias: None,
5555            bright_query_id: None,
5556            bright_query_org_id: None,
5557            bvd_id: None,
5558            classification: None,
5559            country: None,
5560            created_at: None,
5561            description: None,
5562            dissolution_date: None,
5563            duns_code: None,
5564            email: None,
5565            icij_id: None,
5566            id_number: None,
5567            incorporation_date: None,
5568            index_text: None,
5569            inn_code: None,
5570            jurisdiction: None,
5571            keywords: None,
5572            legal_form: None,
5573            lei_code: None,
5574            license_number: None,
5575            main_country: None,
5576            modified_at: None,
5577            name: Vec::new(),
5578            notes: None,
5579            npi_code: None,
5580            ogrn_code: None,
5581            okpo_code: None,
5582            opencorporates_url: None,
5583            parent: None,
5584            phone: None,
5585            previous_name: None,
5586            program: None,
5587            program_id: None,
5588            proof: None,
5589            publisher: None,
5590            publisher_url: None,
5591            registration_number: None,
5592            retrieved_at: None,
5593            sayari_id: None,
5594            sector: None,
5595            source_url: None,
5596            status: None,
5597            summary: None,
5598            swift_bic: None,
5599            tax_number: None,
5600            tax_status: None,
5601            topics: None,
5602            unique_entity_id: None,
5603            usc_code: None,
5604            vat_code: None,
5605            weak_alias: None,
5606            website: None,
5607            wikidata_id: None,
5608            wikipedia_url: None,
5609        }
5610    }
5611    /// Get the schema name
5612    pub fn schema_name() -> &'static str {
5613        "LegalEntity"
5614    }
5615}
5616///FTM Schema: License
5617#[derive(Debug, Clone, Serialize, Deserialize)]
5618#[cfg_attr(feature = "builder", derive(Builder))]
5619#[serde(rename_all = "camelCase")]
5620pub struct License {
5621    pub id: String,
5622    #[cfg_attr(feature = "builder", builder(default = "License".to_string()))]
5623    pub schema: String,
5624    ///Property: Address
5625    #[serde(skip_serializing_if = "Option::is_none")]
5626    pub address: Option<Vec<String>>,
5627    ///Property: Address
5628    #[serde(skip_serializing_if = "Option::is_none")]
5629    pub address_entity: Option<Vec<String>>,
5630    ///Property: Aleph URL
5631    #[serde(skip_serializing_if = "Option::is_none")]
5632    pub aleph_url: Option<Vec<String>>,
5633    ///Property: Alias
5634    #[serde(skip_serializing_if = "Option::is_none")]
5635    pub alias: Option<Vec<String>>,
5636    ///Property: Amount
5637    #[serde(
5638        skip_serializing_if = "Option::is_none",
5639        deserialize_with = "deserialize_opt_f64_vec",
5640        default
5641    )]
5642    pub amount: Option<Vec<f64>>,
5643    ///Property: Amount in EUR
5644    #[serde(
5645        skip_serializing_if = "Option::is_none",
5646        deserialize_with = "deserialize_opt_f64_vec",
5647        default
5648    )]
5649    pub amount_eur: Option<Vec<f64>>,
5650    ///Property: Amount in USD
5651    #[serde(
5652        skip_serializing_if = "Option::is_none",
5653        deserialize_with = "deserialize_opt_f64_vec",
5654        default
5655    )]
5656    pub amount_usd: Option<Vec<f64>>,
5657    ///Property: Area
5658    #[serde(
5659        skip_serializing_if = "Option::is_none",
5660        deserialize_with = "deserialize_opt_f64_vec",
5661        default
5662    )]
5663    pub area: Option<Vec<f64>>,
5664    ///Property: Contract authority
5665    #[serde(default)]
5666    pub authority: Vec<String>,
5667    ///Property: Cancelled?
5668    #[serde(skip_serializing_if = "Option::is_none")]
5669    pub cancelled: Option<Vec<String>>,
5670    ///Property: Classification
5671    #[serde(skip_serializing_if = "Option::is_none")]
5672    pub classification: Option<Vec<String>>,
5673    ///Property: Commodities
5674    #[serde(skip_serializing_if = "Option::is_none")]
5675    pub commodities: Option<Vec<String>>,
5676    ///Property: Contract date
5677    #[serde(skip_serializing_if = "Option::is_none")]
5678    pub contract_date: Option<Vec<String>>,
5679    ///Property: Country
5680    #[serde(skip_serializing_if = "Option::is_none")]
5681    pub country: Option<Vec<String>>,
5682    ///Property: Created at
5683    #[serde(skip_serializing_if = "Option::is_none")]
5684    pub created_at: Option<Vec<String>>,
5685    ///Property: Contract award criteria
5686    #[serde(skip_serializing_if = "Option::is_none")]
5687    pub criteria: Option<Vec<String>>,
5688    ///Property: Currency
5689    #[serde(skip_serializing_if = "Option::is_none")]
5690    pub currency: Option<Vec<String>>,
5691    ///Property: Description
5692    #[serde(skip_serializing_if = "Option::is_none")]
5693    pub description: Option<Vec<String>>,
5694    ///Property: Index text
5695    #[serde(skip_serializing_if = "Option::is_none")]
5696    pub index_text: Option<Vec<String>>,
5697    ///Property: Keywords
5698    #[serde(skip_serializing_if = "Option::is_none")]
5699    pub keywords: Option<Vec<String>>,
5700    ///Property: Language
5701    #[serde(skip_serializing_if = "Option::is_none")]
5702    pub language: Option<Vec<String>>,
5703    ///Property: Procurement method
5704    #[serde(skip_serializing_if = "Option::is_none")]
5705    pub method: Option<Vec<String>>,
5706    ///Property: Modified on
5707    #[serde(skip_serializing_if = "Option::is_none")]
5708    pub modified_at: Option<Vec<String>>,
5709    ///Property: Name
5710    #[serde(default)]
5711    pub name: Vec<String>,
5712    ///Property: Notes
5713    #[serde(skip_serializing_if = "Option::is_none")]
5714    pub notes: Option<Vec<String>>,
5715    ///Property: Contract Award Notice ID
5716    #[serde(skip_serializing_if = "Option::is_none")]
5717    pub notice_id: Option<Vec<String>>,
5718    ///Property: Number of awards
5719    #[serde(skip_serializing_if = "Option::is_none")]
5720    pub number_awards: Option<Vec<String>>,
5721    ///Property: Previous name
5722    #[serde(skip_serializing_if = "Option::is_none")]
5723    pub previous_name: Option<Vec<String>>,
5724    ///Property: Contract procedure
5725    #[serde(skip_serializing_if = "Option::is_none")]
5726    pub procedure: Option<Vec<String>>,
5727    ///Property: Procedure number
5728    #[serde(skip_serializing_if = "Option::is_none")]
5729    pub procedure_number: Option<Vec<String>>,
5730    ///Property: Program
5731    #[serde(skip_serializing_if = "Option::is_none")]
5732    pub program: Option<Vec<String>>,
5733    ///Property: Program ID
5734    #[serde(skip_serializing_if = "Option::is_none")]
5735    pub program_id: Option<Vec<String>>,
5736    ///Property: Project
5737    #[serde(skip_serializing_if = "Option::is_none")]
5738    pub project: Option<Vec<String>>,
5739    ///Property: Source document
5740    #[serde(skip_serializing_if = "Option::is_none")]
5741    pub proof: Option<Vec<String>>,
5742    ///Property: Publishing source
5743    #[serde(skip_serializing_if = "Option::is_none")]
5744    pub publisher: Option<Vec<String>>,
5745    ///Property: Publishing source URL
5746    #[serde(skip_serializing_if = "Option::is_none")]
5747    pub publisher_url: Option<Vec<String>>,
5748    ///Property: Retrieved on
5749    #[serde(skip_serializing_if = "Option::is_none")]
5750    pub retrieved_at: Option<Vec<String>>,
5751    ///Property: License review date
5752    #[serde(skip_serializing_if = "Option::is_none")]
5753    pub review_date: Option<Vec<String>>,
5754    ///Property: Source link
5755    #[serde(skip_serializing_if = "Option::is_none")]
5756    pub source_url: Option<Vec<String>>,
5757    ///Property: Status
5758    #[serde(skip_serializing_if = "Option::is_none")]
5759    pub status: Option<Vec<String>>,
5760    ///Property: Summary
5761    #[serde(skip_serializing_if = "Option::is_none")]
5762    pub summary: Option<Vec<String>>,
5763    ///Property: Title
5764    #[serde(default)]
5765    pub title: Vec<String>,
5766    ///Property: Topics
5767    #[serde(skip_serializing_if = "Option::is_none")]
5768    pub topics: Option<Vec<String>>,
5769    ///Property: Type
5770    #[serde(skip_serializing_if = "Option::is_none")]
5771    pub type_: Option<Vec<String>>,
5772    ///Property: Weak alias
5773    #[serde(skip_serializing_if = "Option::is_none")]
5774    pub weak_alias: Option<Vec<String>>,
5775    ///Property: Wikidata ID
5776    #[serde(skip_serializing_if = "Option::is_none")]
5777    pub wikidata_id: Option<Vec<String>>,
5778    ///Property: Wikipedia Article
5779    #[serde(skip_serializing_if = "Option::is_none")]
5780    pub wikipedia_url: Option<Vec<String>>,
5781}
5782impl License {
5783    /// Create a new entity with the given ID
5784    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
5785    pub fn new(id: impl Into<String>) -> Self {
5786        Self {
5787            id: id.into(),
5788            schema: "License".to_string(),
5789            address: None,
5790            address_entity: None,
5791            aleph_url: None,
5792            alias: None,
5793            amount: None,
5794            amount_eur: None,
5795            amount_usd: None,
5796            area: None,
5797            authority: Vec::new(),
5798            cancelled: None,
5799            classification: None,
5800            commodities: None,
5801            contract_date: None,
5802            country: None,
5803            created_at: None,
5804            criteria: None,
5805            currency: None,
5806            description: None,
5807            index_text: None,
5808            keywords: None,
5809            language: None,
5810            method: None,
5811            modified_at: None,
5812            name: Vec::new(),
5813            notes: None,
5814            notice_id: None,
5815            number_awards: None,
5816            previous_name: None,
5817            procedure: None,
5818            procedure_number: None,
5819            program: None,
5820            program_id: None,
5821            project: None,
5822            proof: None,
5823            publisher: None,
5824            publisher_url: None,
5825            retrieved_at: None,
5826            review_date: None,
5827            source_url: None,
5828            status: None,
5829            summary: None,
5830            title: Vec::new(),
5831            topics: None,
5832            type_: None,
5833            weak_alias: None,
5834            wikidata_id: None,
5835            wikipedia_url: None,
5836        }
5837    }
5838    /// Get the schema name
5839    pub fn schema_name() -> &'static str {
5840        "License"
5841    }
5842}
5843///FTM Schema: Membership
5844#[derive(Debug, Clone, Serialize, Deserialize)]
5845#[cfg_attr(feature = "builder", derive(Builder))]
5846#[serde(rename_all = "camelCase")]
5847pub struct Membership {
5848    pub id: String,
5849    #[cfg_attr(feature = "builder", builder(default = "Membership".to_string()))]
5850    pub schema: String,
5851    ///Property: Aleph URL
5852    #[serde(skip_serializing_if = "Option::is_none")]
5853    pub aleph_url: Option<Vec<String>>,
5854    ///Property: Date
5855    #[serde(skip_serializing_if = "Option::is_none")]
5856    pub date: Option<Vec<String>>,
5857    ///Property: Description
5858    #[serde(skip_serializing_if = "Option::is_none")]
5859    pub description: Option<Vec<String>>,
5860    ///Property: End date
5861    #[serde(skip_serializing_if = "Option::is_none")]
5862    pub end_date: Option<Vec<String>>,
5863    ///Property: Index text
5864    #[serde(skip_serializing_if = "Option::is_none")]
5865    pub index_text: Option<Vec<String>>,
5866    ///Property: Member
5867    #[serde(default)]
5868    pub member: Vec<String>,
5869    ///Property: Modified on
5870    #[serde(skip_serializing_if = "Option::is_none")]
5871    pub modified_at: Option<Vec<String>>,
5872    ///Property: Detected names
5873    #[serde(skip_serializing_if = "Option::is_none")]
5874    pub names_mentioned: Option<Vec<String>>,
5875    ///Property: Organization
5876    #[serde(default)]
5877    pub organization: Vec<String>,
5878    ///Property: Source document
5879    #[serde(skip_serializing_if = "Option::is_none")]
5880    pub proof: Option<Vec<String>>,
5881    ///Property: Publishing source
5882    #[serde(skip_serializing_if = "Option::is_none")]
5883    pub publisher: Option<Vec<String>>,
5884    ///Property: Publishing source URL
5885    #[serde(skip_serializing_if = "Option::is_none")]
5886    pub publisher_url: Option<Vec<String>>,
5887    ///Property: Record ID
5888    #[serde(skip_serializing_if = "Option::is_none")]
5889    pub record_id: Option<Vec<String>>,
5890    ///Property: Retrieved on
5891    #[serde(skip_serializing_if = "Option::is_none")]
5892    pub retrieved_at: Option<Vec<String>>,
5893    ///Property: Role
5894    #[serde(skip_serializing_if = "Option::is_none")]
5895    pub role: Option<Vec<String>>,
5896    ///Property: Source link
5897    #[serde(skip_serializing_if = "Option::is_none")]
5898    pub source_url: Option<Vec<String>>,
5899    ///Property: Start date
5900    #[serde(skip_serializing_if = "Option::is_none")]
5901    pub start_date: Option<Vec<String>>,
5902    ///Property: Status
5903    #[serde(skip_serializing_if = "Option::is_none")]
5904    pub status: Option<Vec<String>>,
5905    ///Property: Summary
5906    #[serde(skip_serializing_if = "Option::is_none")]
5907    pub summary: Option<Vec<String>>,
5908}
5909impl Membership {
5910    /// Create a new entity with the given ID
5911    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
5912    pub fn new(id: impl Into<String>) -> Self {
5913        Self {
5914            id: id.into(),
5915            schema: "Membership".to_string(),
5916            aleph_url: None,
5917            date: None,
5918            description: None,
5919            end_date: None,
5920            index_text: None,
5921            member: Vec::new(),
5922            modified_at: None,
5923            names_mentioned: None,
5924            organization: Vec::new(),
5925            proof: None,
5926            publisher: None,
5927            publisher_url: None,
5928            record_id: None,
5929            retrieved_at: None,
5930            role: None,
5931            source_url: None,
5932            start_date: None,
5933            status: None,
5934            summary: None,
5935        }
5936    }
5937    /// Get the schema name
5938    pub fn schema_name() -> &'static str {
5939        "Membership"
5940    }
5941}
5942///FTM Schema: Mention
5943#[derive(Debug, Clone, Serialize, Deserialize)]
5944#[cfg_attr(feature = "builder", derive(Builder))]
5945#[serde(rename_all = "camelCase")]
5946pub struct Mention {
5947    pub id: String,
5948    #[cfg_attr(feature = "builder", builder(default = "Mention".to_string()))]
5949    pub schema: String,
5950    ///Property: Co-occurring countries
5951    #[serde(skip_serializing_if = "Option::is_none")]
5952    pub context_country: Option<Vec<String>>,
5953    ///Property: Co-occurring e-mail addresses
5954    #[serde(skip_serializing_if = "Option::is_none")]
5955    pub context_email: Option<Vec<String>>,
5956    ///Property: Co-occurring phone numbers
5957    #[serde(skip_serializing_if = "Option::is_none")]
5958    pub context_phone: Option<Vec<String>>,
5959    ///Property: Detected entity type
5960    #[serde(skip_serializing_if = "Option::is_none")]
5961    pub detected_schema: Option<Vec<String>>,
5962    ///Property: Document
5963    #[serde(default)]
5964    pub document: Vec<String>,
5965    ///Property: Name
5966    #[serde(default)]
5967    pub name: Vec<String>,
5968    ///Property: Entity
5969    #[serde(skip_serializing_if = "Option::is_none")]
5970    pub resolved: Option<Vec<String>>,
5971}
5972impl Mention {
5973    /// Create a new entity with the given ID
5974    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
5975    pub fn new(id: impl Into<String>) -> Self {
5976        Self {
5977            id: id.into(),
5978            schema: "Mention".to_string(),
5979            context_country: None,
5980            context_email: None,
5981            context_phone: None,
5982            detected_schema: None,
5983            document: Vec::new(),
5984            name: Vec::new(),
5985            resolved: None,
5986        }
5987    }
5988    /// Get the schema name
5989    pub fn schema_name() -> &'static str {
5990        "Mention"
5991    }
5992}
5993///FTM Schema: Message
5994#[derive(Debug, Clone, Serialize, Deserialize)]
5995#[cfg_attr(feature = "builder", derive(Builder))]
5996#[serde(rename_all = "camelCase")]
5997pub struct Message {
5998    pub id: String,
5999    #[cfg_attr(feature = "builder", builder(default = "Message".to_string()))]
6000    pub schema: String,
6001    ///Property: Address
6002    #[serde(skip_serializing_if = "Option::is_none")]
6003    pub address: Option<Vec<String>>,
6004    ///Property: Address
6005    #[serde(skip_serializing_if = "Option::is_none")]
6006    pub address_entity: Option<Vec<String>>,
6007    ///Property: Aleph URL
6008    #[serde(skip_serializing_if = "Option::is_none")]
6009    pub aleph_url: Option<Vec<String>>,
6010    ///Property: Alias
6011    #[serde(skip_serializing_if = "Option::is_none")]
6012    pub alias: Option<Vec<String>>,
6013    ///Property: Ancestors
6014    #[serde(skip_serializing_if = "Option::is_none")]
6015    pub ancestors: Option<Vec<String>>,
6016    ///Property: Author
6017    #[serde(skip_serializing_if = "Option::is_none")]
6018    pub author: Option<Vec<String>>,
6019    ///Property: Authored on
6020    #[serde(skip_serializing_if = "Option::is_none")]
6021    pub authored_at: Option<Vec<String>>,
6022    ///Property: HTML
6023    #[serde(skip_serializing_if = "Option::is_none")]
6024    pub body_html: Option<Vec<String>>,
6025    ///Property: Text
6026    #[serde(default)]
6027    pub body_text: Vec<String>,
6028    ///Property: Detected companies
6029    #[serde(skip_serializing_if = "Option::is_none")]
6030    pub companies_mentioned: Option<Vec<String>>,
6031    ///Property: Checksum
6032    #[serde(skip_serializing_if = "Option::is_none")]
6033    pub content_hash: Option<Vec<String>>,
6034    ///Property: Country
6035    #[serde(skip_serializing_if = "Option::is_none")]
6036    pub country: Option<Vec<String>>,
6037    ///Property: Crawler
6038    #[serde(skip_serializing_if = "Option::is_none")]
6039    pub crawler: Option<Vec<String>>,
6040    ///Property: Created at
6041    #[serde(skip_serializing_if = "Option::is_none")]
6042    pub created_at: Option<Vec<String>>,
6043    ///Property: Date
6044    #[serde(skip_serializing_if = "Option::is_none")]
6045    pub date: Option<Vec<String>>,
6046    ///Property: Description
6047    #[serde(skip_serializing_if = "Option::is_none")]
6048    pub description: Option<Vec<String>>,
6049    ///Property: Detected country
6050    #[serde(skip_serializing_if = "Option::is_none")]
6051    pub detected_country: Option<Vec<String>>,
6052    ///Property: Detected language
6053    #[serde(skip_serializing_if = "Option::is_none")]
6054    pub detected_language: Option<Vec<String>>,
6055    ///Property: Detected e-mail addresses
6056    #[serde(skip_serializing_if = "Option::is_none")]
6057    pub email_mentioned: Option<Vec<String>>,
6058    ///Property: File encoding
6059    #[serde(skip_serializing_if = "Option::is_none")]
6060    pub encoding: Option<Vec<String>>,
6061    ///Property: End date
6062    #[serde(skip_serializing_if = "Option::is_none")]
6063    pub end_date: Option<Vec<String>>,
6064    ///Property: File extension
6065    #[serde(skip_serializing_if = "Option::is_none")]
6066    pub extension: Option<Vec<String>>,
6067    ///Property: File name
6068    #[serde(default)]
6069    pub file_name: Vec<String>,
6070    ///Property: File size
6071    #[serde(
6072        skip_serializing_if = "Option::is_none",
6073        deserialize_with = "deserialize_opt_f64_vec",
6074        default
6075    )]
6076    pub file_size: Option<Vec<f64>>,
6077    ///Property: Generator
6078    #[serde(skip_serializing_if = "Option::is_none")]
6079    pub generator: Option<Vec<String>>,
6080    ///Property: Detected IBANs
6081    #[serde(skip_serializing_if = "Option::is_none")]
6082    pub iban_mentioned: Option<Vec<String>>,
6083    ///Property: In Reply To
6084    #[serde(skip_serializing_if = "Option::is_none")]
6085    pub in_reply_to: Option<Vec<String>>,
6086    ///Property: Responding to
6087    #[serde(skip_serializing_if = "Option::is_none")]
6088    pub in_reply_to_message: Option<Vec<String>>,
6089    ///Property: Index text
6090    #[serde(skip_serializing_if = "Option::is_none")]
6091    pub index_text: Option<Vec<String>>,
6092    ///Property: Detected IP addresses
6093    #[serde(skip_serializing_if = "Option::is_none")]
6094    pub ip_mentioned: Option<Vec<String>>,
6095    ///Property: Keywords
6096    #[serde(skip_serializing_if = "Option::is_none")]
6097    pub keywords: Option<Vec<String>>,
6098    ///Property: Language
6099    #[serde(skip_serializing_if = "Option::is_none")]
6100    pub language: Option<Vec<String>>,
6101    ///Property: Detected locations
6102    #[serde(skip_serializing_if = "Option::is_none")]
6103    pub location_mentioned: Option<Vec<String>>,
6104    ///Property: Message ID
6105    #[serde(skip_serializing_if = "Option::is_none")]
6106    pub message_id: Option<Vec<String>>,
6107    ///Property: Metadata
6108    #[serde(skip_serializing_if = "Option::is_none")]
6109    pub metadata: Option<serde_json::Value>,
6110    ///Property: MIME type
6111    #[serde(skip_serializing_if = "Option::is_none")]
6112    pub mime_type: Option<Vec<String>>,
6113    ///Property: Modified on
6114    #[serde(skip_serializing_if = "Option::is_none")]
6115    pub modified_at: Option<Vec<String>>,
6116    ///Property: Name
6117    #[serde(default)]
6118    pub name: Vec<String>,
6119    ///Property: Detected names
6120    #[serde(skip_serializing_if = "Option::is_none")]
6121    pub names_mentioned: Option<Vec<String>>,
6122    ///Property: Notes
6123    #[serde(skip_serializing_if = "Option::is_none")]
6124    pub notes: Option<Vec<String>>,
6125    ///Property: Folder
6126    #[serde(skip_serializing_if = "Option::is_none")]
6127    pub parent: Option<Vec<String>>,
6128    ///Property: Detected people
6129    #[serde(skip_serializing_if = "Option::is_none")]
6130    pub people_mentioned: Option<Vec<String>>,
6131    ///Property: Detected phones
6132    #[serde(skip_serializing_if = "Option::is_none")]
6133    pub phone_mentioned: Option<Vec<String>>,
6134    ///Property: Previous name
6135    #[serde(skip_serializing_if = "Option::is_none")]
6136    pub previous_name: Option<Vec<String>>,
6137    ///Property: Processed at
6138    #[serde(skip_serializing_if = "Option::is_none")]
6139    pub processed_at: Option<Vec<String>>,
6140    ///Property: Processing agent
6141    #[serde(skip_serializing_if = "Option::is_none")]
6142    pub processing_agent: Option<Vec<String>>,
6143    ///Property: Processing error
6144    #[serde(skip_serializing_if = "Option::is_none")]
6145    pub processing_error: Option<Vec<String>>,
6146    ///Property: Processing status
6147    #[serde(skip_serializing_if = "Option::is_none")]
6148    pub processing_status: Option<Vec<String>>,
6149    ///Property: Program
6150    #[serde(skip_serializing_if = "Option::is_none")]
6151    pub program: Option<Vec<String>>,
6152    ///Property: Program ID
6153    #[serde(skip_serializing_if = "Option::is_none")]
6154    pub program_id: Option<Vec<String>>,
6155    ///Property: Source document
6156    #[serde(skip_serializing_if = "Option::is_none")]
6157    pub proof: Option<Vec<String>>,
6158    ///Property: Published on
6159    #[serde(skip_serializing_if = "Option::is_none")]
6160    pub published_at: Option<Vec<String>>,
6161    ///Property: Publishing source
6162    #[serde(skip_serializing_if = "Option::is_none")]
6163    pub publisher: Option<Vec<String>>,
6164    ///Property: Publishing source URL
6165    #[serde(skip_serializing_if = "Option::is_none")]
6166    pub publisher_url: Option<Vec<String>>,
6167    ///Property: Recipient Account
6168    #[serde(skip_serializing_if = "Option::is_none")]
6169    pub recipient_account: Option<Vec<String>>,
6170    ///Property: Recipients
6171    #[serde(skip_serializing_if = "Option::is_none")]
6172    pub recipients: Option<Vec<String>>,
6173    ///Property: Record ID
6174    #[serde(skip_serializing_if = "Option::is_none")]
6175    pub record_id: Option<Vec<String>>,
6176    ///Property: Retrieved on
6177    #[serde(skip_serializing_if = "Option::is_none")]
6178    pub retrieved_at: Option<Vec<String>>,
6179    ///Property: Sender
6180    #[serde(default)]
6181    pub sender: Vec<String>,
6182    ///Property: Sender Account
6183    #[serde(skip_serializing_if = "Option::is_none")]
6184    pub sender_account: Option<Vec<String>>,
6185    ///Property: Source link
6186    #[serde(skip_serializing_if = "Option::is_none")]
6187    pub source_url: Option<Vec<String>>,
6188    ///Property: Start date
6189    #[serde(skip_serializing_if = "Option::is_none")]
6190    pub start_date: Option<Vec<String>>,
6191    ///Property: Subject
6192    #[serde(skip_serializing_if = "Option::is_none")]
6193    pub subject: Option<Vec<String>>,
6194    ///Property: Summary
6195    #[serde(skip_serializing_if = "Option::is_none")]
6196    pub summary: Option<Vec<String>>,
6197    ///Property: Thread topic
6198    #[serde(skip_serializing_if = "Option::is_none")]
6199    pub thread_topic: Option<Vec<String>>,
6200    ///Property: Title
6201    #[serde(skip_serializing_if = "Option::is_none")]
6202    pub title: Option<Vec<String>>,
6203    ///Property: Topics
6204    #[serde(skip_serializing_if = "Option::is_none")]
6205    pub topics: Option<Vec<String>>,
6206    ///Property: The language of the translated text
6207    #[serde(skip_serializing_if = "Option::is_none")]
6208    pub translated_language: Option<Vec<String>>,
6209    ///Property: Translated version of the body text
6210    #[serde(skip_serializing_if = "Option::is_none")]
6211    pub translated_text: Option<Vec<String>>,
6212    ///Property: Weak alias
6213    #[serde(skip_serializing_if = "Option::is_none")]
6214    pub weak_alias: Option<Vec<String>>,
6215    ///Property: Wikidata ID
6216    #[serde(skip_serializing_if = "Option::is_none")]
6217    pub wikidata_id: Option<Vec<String>>,
6218    ///Property: Wikipedia Article
6219    #[serde(skip_serializing_if = "Option::is_none")]
6220    pub wikipedia_url: Option<Vec<String>>,
6221}
6222impl Message {
6223    /// Create a new entity with the given ID
6224    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
6225    pub fn new(id: impl Into<String>) -> Self {
6226        Self {
6227            id: id.into(),
6228            schema: "Message".to_string(),
6229            address: None,
6230            address_entity: None,
6231            aleph_url: None,
6232            alias: None,
6233            ancestors: None,
6234            author: None,
6235            authored_at: None,
6236            body_html: None,
6237            body_text: Vec::new(),
6238            companies_mentioned: None,
6239            content_hash: None,
6240            country: None,
6241            crawler: None,
6242            created_at: None,
6243            date: None,
6244            description: None,
6245            detected_country: None,
6246            detected_language: None,
6247            email_mentioned: None,
6248            encoding: None,
6249            end_date: None,
6250            extension: None,
6251            file_name: Vec::new(),
6252            file_size: None,
6253            generator: None,
6254            iban_mentioned: None,
6255            in_reply_to: None,
6256            in_reply_to_message: None,
6257            index_text: None,
6258            ip_mentioned: None,
6259            keywords: None,
6260            language: None,
6261            location_mentioned: None,
6262            message_id: None,
6263            metadata: None,
6264            mime_type: None,
6265            modified_at: None,
6266            name: Vec::new(),
6267            names_mentioned: None,
6268            notes: None,
6269            parent: None,
6270            people_mentioned: None,
6271            phone_mentioned: None,
6272            previous_name: None,
6273            processed_at: None,
6274            processing_agent: None,
6275            processing_error: None,
6276            processing_status: None,
6277            program: None,
6278            program_id: None,
6279            proof: None,
6280            published_at: None,
6281            publisher: None,
6282            publisher_url: None,
6283            recipient_account: None,
6284            recipients: None,
6285            record_id: None,
6286            retrieved_at: None,
6287            sender: Vec::new(),
6288            sender_account: None,
6289            source_url: None,
6290            start_date: None,
6291            subject: None,
6292            summary: None,
6293            thread_topic: None,
6294            title: None,
6295            topics: None,
6296            translated_language: None,
6297            translated_text: None,
6298            weak_alias: None,
6299            wikidata_id: None,
6300            wikipedia_url: None,
6301        }
6302    }
6303    /// Get the schema name
6304    pub fn schema_name() -> &'static str {
6305        "Message"
6306    }
6307}
6308///FTM Schema: Note
6309#[derive(Debug, Clone, Serialize, Deserialize)]
6310#[cfg_attr(feature = "builder", derive(Builder))]
6311#[serde(rename_all = "camelCase")]
6312pub struct Note {
6313    pub id: String,
6314    #[cfg_attr(feature = "builder", builder(default = "Note".to_string()))]
6315    pub schema: String,
6316    ///Property: Address
6317    #[serde(skip_serializing_if = "Option::is_none")]
6318    pub address: Option<Vec<String>>,
6319    ///Property: Address
6320    #[serde(skip_serializing_if = "Option::is_none")]
6321    pub address_entity: Option<Vec<String>>,
6322    ///Property: Aleph URL
6323    #[serde(skip_serializing_if = "Option::is_none")]
6324    pub aleph_url: Option<Vec<String>>,
6325    ///Property: Alias
6326    #[serde(skip_serializing_if = "Option::is_none")]
6327    pub alias: Option<Vec<String>>,
6328    ///Property: Detected companies
6329    #[serde(skip_serializing_if = "Option::is_none")]
6330    pub companies_mentioned: Option<Vec<String>>,
6331    ///Property: Country
6332    #[serde(skip_serializing_if = "Option::is_none")]
6333    pub country: Option<Vec<String>>,
6334    ///Property: Created at
6335    #[serde(skip_serializing_if = "Option::is_none")]
6336    pub created_at: Option<Vec<String>>,
6337    ///Property: Description
6338    #[serde(skip_serializing_if = "Option::is_none")]
6339    pub description: Option<Vec<String>>,
6340    ///Property: Detected country
6341    #[serde(skip_serializing_if = "Option::is_none")]
6342    pub detected_country: Option<Vec<String>>,
6343    ///Property: Detected language
6344    #[serde(skip_serializing_if = "Option::is_none")]
6345    pub detected_language: Option<Vec<String>>,
6346    ///Property: Detected e-mail addresses
6347    #[serde(skip_serializing_if = "Option::is_none")]
6348    pub email_mentioned: Option<Vec<String>>,
6349    ///Property: Entity
6350    #[serde(skip_serializing_if = "Option::is_none")]
6351    pub entity: Option<Vec<String>>,
6352    ///Property: Detected IBANs
6353    #[serde(skip_serializing_if = "Option::is_none")]
6354    pub iban_mentioned: Option<Vec<String>>,
6355    ///Property: Index text
6356    #[serde(skip_serializing_if = "Option::is_none")]
6357    pub index_text: Option<Vec<String>>,
6358    ///Property: Detected IP addresses
6359    #[serde(skip_serializing_if = "Option::is_none")]
6360    pub ip_mentioned: Option<Vec<String>>,
6361    ///Property: Keywords
6362    #[serde(skip_serializing_if = "Option::is_none")]
6363    pub keywords: Option<Vec<String>>,
6364    ///Property: Detected locations
6365    #[serde(skip_serializing_if = "Option::is_none")]
6366    pub location_mentioned: Option<Vec<String>>,
6367    ///Property: Modified on
6368    #[serde(skip_serializing_if = "Option::is_none")]
6369    pub modified_at: Option<Vec<String>>,
6370    ///Property: Name
6371    #[serde(default)]
6372    pub name: Vec<String>,
6373    ///Property: Detected names
6374    #[serde(skip_serializing_if = "Option::is_none")]
6375    pub names_mentioned: Option<Vec<String>>,
6376    ///Property: Notes
6377    #[serde(skip_serializing_if = "Option::is_none")]
6378    pub notes: Option<Vec<String>>,
6379    ///Property: Detected people
6380    #[serde(skip_serializing_if = "Option::is_none")]
6381    pub people_mentioned: Option<Vec<String>>,
6382    ///Property: Detected phones
6383    #[serde(skip_serializing_if = "Option::is_none")]
6384    pub phone_mentioned: Option<Vec<String>>,
6385    ///Property: Previous name
6386    #[serde(skip_serializing_if = "Option::is_none")]
6387    pub previous_name: Option<Vec<String>>,
6388    ///Property: Program
6389    #[serde(skip_serializing_if = "Option::is_none")]
6390    pub program: Option<Vec<String>>,
6391    ///Property: Program ID
6392    #[serde(skip_serializing_if = "Option::is_none")]
6393    pub program_id: Option<Vec<String>>,
6394    ///Property: Source document
6395    #[serde(skip_serializing_if = "Option::is_none")]
6396    pub proof: Option<Vec<String>>,
6397    ///Property: Publishing source
6398    #[serde(skip_serializing_if = "Option::is_none")]
6399    pub publisher: Option<Vec<String>>,
6400    ///Property: Publishing source URL
6401    #[serde(skip_serializing_if = "Option::is_none")]
6402    pub publisher_url: Option<Vec<String>>,
6403    ///Property: Retrieved on
6404    #[serde(skip_serializing_if = "Option::is_none")]
6405    pub retrieved_at: Option<Vec<String>>,
6406    ///Property: Source link
6407    #[serde(skip_serializing_if = "Option::is_none")]
6408    pub source_url: Option<Vec<String>>,
6409    ///Property: Summary
6410    #[serde(skip_serializing_if = "Option::is_none")]
6411    pub summary: Option<Vec<String>>,
6412    ///Property: Topics
6413    #[serde(skip_serializing_if = "Option::is_none")]
6414    pub topics: Option<Vec<String>>,
6415    ///Property: Weak alias
6416    #[serde(skip_serializing_if = "Option::is_none")]
6417    pub weak_alias: Option<Vec<String>>,
6418    ///Property: Wikidata ID
6419    #[serde(skip_serializing_if = "Option::is_none")]
6420    pub wikidata_id: Option<Vec<String>>,
6421    ///Property: Wikipedia Article
6422    #[serde(skip_serializing_if = "Option::is_none")]
6423    pub wikipedia_url: Option<Vec<String>>,
6424}
6425impl Note {
6426    /// Create a new entity with the given ID
6427    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
6428    pub fn new(id: impl Into<String>) -> Self {
6429        Self {
6430            id: id.into(),
6431            schema: "Note".to_string(),
6432            address: None,
6433            address_entity: None,
6434            aleph_url: None,
6435            alias: None,
6436            companies_mentioned: None,
6437            country: None,
6438            created_at: None,
6439            description: None,
6440            detected_country: None,
6441            detected_language: None,
6442            email_mentioned: None,
6443            entity: None,
6444            iban_mentioned: None,
6445            index_text: None,
6446            ip_mentioned: None,
6447            keywords: None,
6448            location_mentioned: None,
6449            modified_at: None,
6450            name: Vec::new(),
6451            names_mentioned: None,
6452            notes: None,
6453            people_mentioned: None,
6454            phone_mentioned: None,
6455            previous_name: None,
6456            program: None,
6457            program_id: None,
6458            proof: None,
6459            publisher: None,
6460            publisher_url: None,
6461            retrieved_at: None,
6462            source_url: None,
6463            summary: None,
6464            topics: None,
6465            weak_alias: None,
6466            wikidata_id: None,
6467            wikipedia_url: None,
6468        }
6469    }
6470    /// Get the schema name
6471    pub fn schema_name() -> &'static str {
6472        "Note"
6473    }
6474}
6475///FTM Schema: Occupancy
6476#[derive(Debug, Clone, Serialize, Deserialize)]
6477#[cfg_attr(feature = "builder", derive(Builder))]
6478#[serde(rename_all = "camelCase")]
6479pub struct Occupancy {
6480    pub id: String,
6481    #[cfg_attr(feature = "builder", builder(default = "Occupancy".to_string()))]
6482    pub schema: String,
6483    ///Property: Aleph URL
6484    #[serde(skip_serializing_if = "Option::is_none")]
6485    pub aleph_url: Option<Vec<String>>,
6486    ///Property: Date
6487    #[serde(skip_serializing_if = "Option::is_none")]
6488    pub date: Option<Vec<String>>,
6489    ///Property: Declaration date
6490    #[serde(skip_serializing_if = "Option::is_none")]
6491    pub declaration_date: Option<Vec<String>>,
6492    ///Property: Description
6493    #[serde(skip_serializing_if = "Option::is_none")]
6494    pub description: Option<Vec<String>>,
6495    ///Property: End date
6496    #[serde(skip_serializing_if = "Option::is_none")]
6497    pub end_date: Option<Vec<String>>,
6498    ///Property: Holder
6499    #[serde(default)]
6500    pub holder: Vec<String>,
6501    ///Property: Index text
6502    #[serde(skip_serializing_if = "Option::is_none")]
6503    pub index_text: Option<Vec<String>>,
6504    ///Property: Modified on
6505    #[serde(skip_serializing_if = "Option::is_none")]
6506    pub modified_at: Option<Vec<String>>,
6507    ///Property: Detected names
6508    #[serde(skip_serializing_if = "Option::is_none")]
6509    pub names_mentioned: Option<Vec<String>>,
6510    ///Property: Position occupied
6511    #[serde(default)]
6512    pub post: Vec<String>,
6513    ///Property: Source document
6514    #[serde(skip_serializing_if = "Option::is_none")]
6515    pub proof: Option<Vec<String>>,
6516    ///Property: Publishing source
6517    #[serde(skip_serializing_if = "Option::is_none")]
6518    pub publisher: Option<Vec<String>>,
6519    ///Property: Publishing source URL
6520    #[serde(skip_serializing_if = "Option::is_none")]
6521    pub publisher_url: Option<Vec<String>>,
6522    ///Property: Record ID
6523    #[serde(skip_serializing_if = "Option::is_none")]
6524    pub record_id: Option<Vec<String>>,
6525    ///Property: Retrieved on
6526    #[serde(skip_serializing_if = "Option::is_none")]
6527    pub retrieved_at: Option<Vec<String>>,
6528    ///Property: Source link
6529    #[serde(skip_serializing_if = "Option::is_none")]
6530    pub source_url: Option<Vec<String>>,
6531    ///Property: Start date
6532    #[serde(skip_serializing_if = "Option::is_none")]
6533    pub start_date: Option<Vec<String>>,
6534    ///Property: Status
6535    #[serde(skip_serializing_if = "Option::is_none")]
6536    pub status: Option<Vec<String>>,
6537    ///Property: Summary
6538    #[serde(skip_serializing_if = "Option::is_none")]
6539    pub summary: Option<Vec<String>>,
6540}
6541impl Occupancy {
6542    /// Create a new entity with the given ID
6543    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
6544    pub fn new(id: impl Into<String>) -> Self {
6545        Self {
6546            id: id.into(),
6547            schema: "Occupancy".to_string(),
6548            aleph_url: None,
6549            date: None,
6550            declaration_date: None,
6551            description: None,
6552            end_date: None,
6553            holder: Vec::new(),
6554            index_text: None,
6555            modified_at: None,
6556            names_mentioned: None,
6557            post: Vec::new(),
6558            proof: None,
6559            publisher: None,
6560            publisher_url: None,
6561            record_id: None,
6562            retrieved_at: None,
6563            source_url: None,
6564            start_date: None,
6565            status: None,
6566            summary: None,
6567        }
6568    }
6569    /// Get the schema name
6570    pub fn schema_name() -> &'static str {
6571        "Occupancy"
6572    }
6573}
6574///FTM Schema: Organization
6575#[derive(Debug, Clone, Serialize, Deserialize)]
6576#[cfg_attr(feature = "builder", derive(Builder))]
6577#[serde(rename_all = "camelCase")]
6578pub struct Organization {
6579    pub id: String,
6580    #[cfg_attr(feature = "builder", builder(default = "Organization".to_string()))]
6581    pub schema: String,
6582    ///Property: Abbreviation
6583    #[serde(skip_serializing_if = "Option::is_none")]
6584    pub abbreviation: Option<Vec<String>>,
6585    ///Property: Address
6586    #[serde(skip_serializing_if = "Option::is_none")]
6587    pub address: Option<Vec<String>>,
6588    ///Property: Address
6589    #[serde(skip_serializing_if = "Option::is_none")]
6590    pub address_entity: Option<Vec<String>>,
6591    ///Property: Aleph URL
6592    #[serde(skip_serializing_if = "Option::is_none")]
6593    pub aleph_url: Option<Vec<String>>,
6594    ///Property: Alias
6595    #[serde(skip_serializing_if = "Option::is_none")]
6596    pub alias: Option<Vec<String>>,
6597    ///Property: BrightQuery ID
6598    #[serde(skip_serializing_if = "Option::is_none")]
6599    pub bright_query_id: Option<Vec<String>>,
6600    ///Property: BrightQuery Organization ID
6601    #[serde(skip_serializing_if = "Option::is_none")]
6602    pub bright_query_org_id: Option<Vec<String>>,
6603    ///Property: Bureau van Dijk ID
6604    #[serde(skip_serializing_if = "Option::is_none")]
6605    pub bvd_id: Option<Vec<String>>,
6606    ///Property: CAGE
6607    #[serde(skip_serializing_if = "Option::is_none")]
6608    pub cage_code: Option<Vec<String>>,
6609    ///Property: Classification
6610    #[serde(skip_serializing_if = "Option::is_none")]
6611    pub classification: Option<Vec<String>>,
6612    ///Property: Country
6613    #[serde(skip_serializing_if = "Option::is_none")]
6614    pub country: Option<Vec<String>>,
6615    ///Property: Created at
6616    #[serde(skip_serializing_if = "Option::is_none")]
6617    pub created_at: Option<Vec<String>>,
6618    ///Property: Description
6619    #[serde(skip_serializing_if = "Option::is_none")]
6620    pub description: Option<Vec<String>>,
6621    ///Property: Dissolution date
6622    #[serde(skip_serializing_if = "Option::is_none")]
6623    pub dissolution_date: Option<Vec<String>>,
6624    ///Property: DUNS
6625    #[serde(skip_serializing_if = "Option::is_none")]
6626    pub duns_code: Option<Vec<String>>,
6627    ///Property: E-Mail
6628    #[serde(skip_serializing_if = "Option::is_none")]
6629    pub email: Option<Vec<String>>,
6630    ///Property: GIIN
6631    #[serde(skip_serializing_if = "Option::is_none")]
6632    pub gii_number: Option<Vec<String>>,
6633    ///Property: ICIJ ID
6634    #[serde(skip_serializing_if = "Option::is_none")]
6635    pub icij_id: Option<Vec<String>>,
6636    ///Property: ID Number
6637    #[serde(skip_serializing_if = "Option::is_none")]
6638    pub id_number: Option<Vec<String>>,
6639    ///Property: IMO Number
6640    #[serde(skip_serializing_if = "Option::is_none")]
6641    pub imo_number: Option<Vec<String>>,
6642    ///Property: Incorporation date
6643    #[serde(skip_serializing_if = "Option::is_none")]
6644    pub incorporation_date: Option<Vec<String>>,
6645    ///Property: Index text
6646    #[serde(skip_serializing_if = "Option::is_none")]
6647    pub index_text: Option<Vec<String>>,
6648    ///Property: INN
6649    #[serde(skip_serializing_if = "Option::is_none")]
6650    pub inn_code: Option<Vec<String>>,
6651    ///Property: Jurisdiction
6652    #[serde(skip_serializing_if = "Option::is_none")]
6653    pub jurisdiction: Option<Vec<String>>,
6654    ///Property: Keywords
6655    #[serde(skip_serializing_if = "Option::is_none")]
6656    pub keywords: Option<Vec<String>>,
6657    ///Property: Legal form
6658    #[serde(skip_serializing_if = "Option::is_none")]
6659    pub legal_form: Option<Vec<String>>,
6660    ///Property: LEI
6661    #[serde(skip_serializing_if = "Option::is_none")]
6662    pub lei_code: Option<Vec<String>>,
6663    ///Property: License Number
6664    #[serde(skip_serializing_if = "Option::is_none")]
6665    pub license_number: Option<Vec<String>>,
6666    ///Property: Country of origin
6667    #[serde(skip_serializing_if = "Option::is_none")]
6668    pub main_country: Option<Vec<String>>,
6669    ///Property: Modified on
6670    #[serde(skip_serializing_if = "Option::is_none")]
6671    pub modified_at: Option<Vec<String>>,
6672    ///Property: Name
6673    #[serde(default)]
6674    pub name: Vec<String>,
6675    ///Property: Notes
6676    #[serde(skip_serializing_if = "Option::is_none")]
6677    pub notes: Option<Vec<String>>,
6678    ///Property: NPI
6679    #[serde(skip_serializing_if = "Option::is_none")]
6680    pub npi_code: Option<Vec<String>>,
6681    ///Property: OGRN
6682    #[serde(skip_serializing_if = "Option::is_none")]
6683    pub ogrn_code: Option<Vec<String>>,
6684    ///Property: OKPO
6685    #[serde(skip_serializing_if = "Option::is_none")]
6686    pub okpo_code: Option<Vec<String>>,
6687    ///Property: OpenCorporates URL
6688    #[serde(skip_serializing_if = "Option::is_none")]
6689    pub opencorporates_url: Option<Vec<String>>,
6690    ///Property: Parent company
6691    #[serde(skip_serializing_if = "Option::is_none")]
6692    pub parent: Option<Vec<String>>,
6693    ///Property: PermID
6694    #[serde(skip_serializing_if = "Option::is_none")]
6695    pub perm_id: Option<Vec<String>>,
6696    ///Property: Phone
6697    #[serde(skip_serializing_if = "Option::is_none")]
6698    pub phone: Option<Vec<String>>,
6699    ///Property: Previous name
6700    #[serde(skip_serializing_if = "Option::is_none")]
6701    pub previous_name: Option<Vec<String>>,
6702    ///Property: Program
6703    #[serde(skip_serializing_if = "Option::is_none")]
6704    pub program: Option<Vec<String>>,
6705    ///Property: Program ID
6706    #[serde(skip_serializing_if = "Option::is_none")]
6707    pub program_id: Option<Vec<String>>,
6708    ///Property: Source document
6709    #[serde(skip_serializing_if = "Option::is_none")]
6710    pub proof: Option<Vec<String>>,
6711    ///Property: Publishing source
6712    #[serde(skip_serializing_if = "Option::is_none")]
6713    pub publisher: Option<Vec<String>>,
6714    ///Property: Publishing source URL
6715    #[serde(skip_serializing_if = "Option::is_none")]
6716    pub publisher_url: Option<Vec<String>>,
6717    ///Property: Registration number
6718    #[serde(skip_serializing_if = "Option::is_none")]
6719    pub registration_number: Option<Vec<String>>,
6720    ///Property: Retrieved on
6721    #[serde(skip_serializing_if = "Option::is_none")]
6722    pub retrieved_at: Option<Vec<String>>,
6723    ///Property: Sayari Entity ID
6724    #[serde(skip_serializing_if = "Option::is_none")]
6725    pub sayari_id: Option<Vec<String>>,
6726    ///Property: Sector
6727    #[serde(skip_serializing_if = "Option::is_none")]
6728    pub sector: Option<Vec<String>>,
6729    ///Property: Source link
6730    #[serde(skip_serializing_if = "Option::is_none")]
6731    pub source_url: Option<Vec<String>>,
6732    ///Property: Status
6733    #[serde(skip_serializing_if = "Option::is_none")]
6734    pub status: Option<Vec<String>>,
6735    ///Property: Summary
6736    #[serde(skip_serializing_if = "Option::is_none")]
6737    pub summary: Option<Vec<String>>,
6738    ///Property: SWIFT/BIC
6739    #[serde(skip_serializing_if = "Option::is_none")]
6740    pub swift_bic: Option<Vec<String>>,
6741    ///Property: Tax Number
6742    #[serde(skip_serializing_if = "Option::is_none")]
6743    pub tax_number: Option<Vec<String>>,
6744    ///Property: Tax status
6745    #[serde(skip_serializing_if = "Option::is_none")]
6746    pub tax_status: Option<Vec<String>>,
6747    ///Property: Topics
6748    #[serde(skip_serializing_if = "Option::is_none")]
6749    pub topics: Option<Vec<String>>,
6750    ///Property: Unique Entity ID
6751    #[serde(skip_serializing_if = "Option::is_none")]
6752    pub unique_entity_id: Option<Vec<String>>,
6753    ///Property: USCC
6754    #[serde(skip_serializing_if = "Option::is_none")]
6755    pub usc_code: Option<Vec<String>>,
6756    ///Property: V.A.T. Identifier
6757    #[serde(skip_serializing_if = "Option::is_none")]
6758    pub vat_code: Option<Vec<String>>,
6759    ///Property: Weak alias
6760    #[serde(skip_serializing_if = "Option::is_none")]
6761    pub weak_alias: Option<Vec<String>>,
6762    ///Property: Website
6763    #[serde(skip_serializing_if = "Option::is_none")]
6764    pub website: Option<Vec<String>>,
6765    ///Property: Wikidata ID
6766    #[serde(skip_serializing_if = "Option::is_none")]
6767    pub wikidata_id: Option<Vec<String>>,
6768    ///Property: Wikipedia Article
6769    #[serde(skip_serializing_if = "Option::is_none")]
6770    pub wikipedia_url: Option<Vec<String>>,
6771}
6772impl Organization {
6773    /// Create a new entity with the given ID
6774    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
6775    pub fn new(id: impl Into<String>) -> Self {
6776        Self {
6777            id: id.into(),
6778            schema: "Organization".to_string(),
6779            abbreviation: None,
6780            address: None,
6781            address_entity: None,
6782            aleph_url: None,
6783            alias: None,
6784            bright_query_id: None,
6785            bright_query_org_id: None,
6786            bvd_id: None,
6787            cage_code: None,
6788            classification: None,
6789            country: None,
6790            created_at: None,
6791            description: None,
6792            dissolution_date: None,
6793            duns_code: None,
6794            email: None,
6795            gii_number: None,
6796            icij_id: None,
6797            id_number: None,
6798            imo_number: None,
6799            incorporation_date: None,
6800            index_text: None,
6801            inn_code: None,
6802            jurisdiction: None,
6803            keywords: None,
6804            legal_form: None,
6805            lei_code: None,
6806            license_number: None,
6807            main_country: None,
6808            modified_at: None,
6809            name: Vec::new(),
6810            notes: None,
6811            npi_code: None,
6812            ogrn_code: None,
6813            okpo_code: None,
6814            opencorporates_url: None,
6815            parent: None,
6816            perm_id: None,
6817            phone: None,
6818            previous_name: None,
6819            program: None,
6820            program_id: None,
6821            proof: None,
6822            publisher: None,
6823            publisher_url: None,
6824            registration_number: None,
6825            retrieved_at: None,
6826            sayari_id: None,
6827            sector: None,
6828            source_url: None,
6829            status: None,
6830            summary: None,
6831            swift_bic: None,
6832            tax_number: None,
6833            tax_status: None,
6834            topics: None,
6835            unique_entity_id: None,
6836            usc_code: None,
6837            vat_code: None,
6838            weak_alias: None,
6839            website: None,
6840            wikidata_id: None,
6841            wikipedia_url: None,
6842        }
6843    }
6844    /// Get the schema name
6845    pub fn schema_name() -> &'static str {
6846        "Organization"
6847    }
6848}
6849///FTM Schema: Ownership
6850#[derive(Debug, Clone, Serialize, Deserialize)]
6851#[cfg_attr(feature = "builder", derive(Builder))]
6852#[serde(rename_all = "camelCase")]
6853pub struct Ownership {
6854    pub id: String,
6855    #[cfg_attr(feature = "builder", builder(default = "Ownership".to_string()))]
6856    pub schema: String,
6857    ///Property: Aleph URL
6858    #[serde(skip_serializing_if = "Option::is_none")]
6859    pub aleph_url: Option<Vec<String>>,
6860    ///Property: Asset
6861    #[serde(default)]
6862    pub asset: Vec<String>,
6863    ///Property: Date
6864    #[serde(skip_serializing_if = "Option::is_none")]
6865    pub date: Option<Vec<String>>,
6866    ///Property: Description
6867    #[serde(skip_serializing_if = "Option::is_none")]
6868    pub description: Option<Vec<String>>,
6869    ///Property: End date
6870    #[serde(skip_serializing_if = "Option::is_none")]
6871    pub end_date: Option<Vec<String>>,
6872    ///Property: Index text
6873    #[serde(skip_serializing_if = "Option::is_none")]
6874    pub index_text: Option<Vec<String>>,
6875    ///Property: Legal basis
6876    #[serde(skip_serializing_if = "Option::is_none")]
6877    pub legal_basis: Option<Vec<String>>,
6878    ///Property: Modified on
6879    #[serde(skip_serializing_if = "Option::is_none")]
6880    pub modified_at: Option<Vec<String>>,
6881    ///Property: Detected names
6882    #[serde(skip_serializing_if = "Option::is_none")]
6883    pub names_mentioned: Option<Vec<String>>,
6884    ///Property: Owner
6885    #[serde(default)]
6886    pub owner: Vec<String>,
6887    ///Property: Type of ownership
6888    #[serde(skip_serializing_if = "Option::is_none")]
6889    pub ownership_type: Option<Vec<String>>,
6890    ///Property: Percentage held
6891    #[serde(skip_serializing_if = "Option::is_none")]
6892    pub percentage: Option<Vec<String>>,
6893    ///Property: Source document
6894    #[serde(skip_serializing_if = "Option::is_none")]
6895    pub proof: Option<Vec<String>>,
6896    ///Property: Publishing source
6897    #[serde(skip_serializing_if = "Option::is_none")]
6898    pub publisher: Option<Vec<String>>,
6899    ///Property: Publishing source URL
6900    #[serde(skip_serializing_if = "Option::is_none")]
6901    pub publisher_url: Option<Vec<String>>,
6902    ///Property: Record ID
6903    #[serde(skip_serializing_if = "Option::is_none")]
6904    pub record_id: Option<Vec<String>>,
6905    ///Property: Retrieved on
6906    #[serde(skip_serializing_if = "Option::is_none")]
6907    pub retrieved_at: Option<Vec<String>>,
6908    ///Property: Role
6909    #[serde(skip_serializing_if = "Option::is_none")]
6910    pub role: Option<Vec<String>>,
6911    ///Property: Number of shares
6912    #[serde(skip_serializing_if = "Option::is_none")]
6913    pub shares_count: Option<Vec<String>>,
6914    ///Property: Currency of shares
6915    #[serde(skip_serializing_if = "Option::is_none")]
6916    pub shares_currency: Option<Vec<String>>,
6917    ///Property: Type of shares
6918    #[serde(skip_serializing_if = "Option::is_none")]
6919    pub shares_type: Option<Vec<String>>,
6920    ///Property: Value of shares
6921    #[serde(skip_serializing_if = "Option::is_none")]
6922    pub shares_value: Option<Vec<String>>,
6923    ///Property: Source link
6924    #[serde(skip_serializing_if = "Option::is_none")]
6925    pub source_url: Option<Vec<String>>,
6926    ///Property: Start date
6927    #[serde(skip_serializing_if = "Option::is_none")]
6928    pub start_date: Option<Vec<String>>,
6929    ///Property: Status
6930    #[serde(skip_serializing_if = "Option::is_none")]
6931    pub status: Option<Vec<String>>,
6932    ///Property: Summary
6933    #[serde(skip_serializing_if = "Option::is_none")]
6934    pub summary: Option<Vec<String>>,
6935}
6936impl Ownership {
6937    /// Create a new entity with the given ID
6938    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
6939    pub fn new(id: impl Into<String>) -> Self {
6940        Self {
6941            id: id.into(),
6942            schema: "Ownership".to_string(),
6943            aleph_url: None,
6944            asset: Vec::new(),
6945            date: None,
6946            description: None,
6947            end_date: None,
6948            index_text: None,
6949            legal_basis: None,
6950            modified_at: None,
6951            names_mentioned: None,
6952            owner: Vec::new(),
6953            ownership_type: None,
6954            percentage: None,
6955            proof: None,
6956            publisher: None,
6957            publisher_url: None,
6958            record_id: None,
6959            retrieved_at: None,
6960            role: None,
6961            shares_count: None,
6962            shares_currency: None,
6963            shares_type: None,
6964            shares_value: None,
6965            source_url: None,
6966            start_date: None,
6967            status: None,
6968            summary: None,
6969        }
6970    }
6971    /// Get the schema name
6972    pub fn schema_name() -> &'static str {
6973        "Ownership"
6974    }
6975}
6976///FTM Schema: Package
6977#[derive(Debug, Clone, Serialize, Deserialize)]
6978#[cfg_attr(feature = "builder", derive(Builder))]
6979#[serde(rename_all = "camelCase")]
6980pub struct Package {
6981    pub id: String,
6982    #[cfg_attr(feature = "builder", builder(default = "Package".to_string()))]
6983    pub schema: String,
6984    ///Property: Address
6985    #[serde(skip_serializing_if = "Option::is_none")]
6986    pub address: Option<Vec<String>>,
6987    ///Property: Address
6988    #[serde(skip_serializing_if = "Option::is_none")]
6989    pub address_entity: Option<Vec<String>>,
6990    ///Property: Aleph URL
6991    #[serde(skip_serializing_if = "Option::is_none")]
6992    pub aleph_url: Option<Vec<String>>,
6993    ///Property: Alias
6994    #[serde(skip_serializing_if = "Option::is_none")]
6995    pub alias: Option<Vec<String>>,
6996    ///Property: Ancestors
6997    #[serde(skip_serializing_if = "Option::is_none")]
6998    pub ancestors: Option<Vec<String>>,
6999    ///Property: Author
7000    #[serde(skip_serializing_if = "Option::is_none")]
7001    pub author: Option<Vec<String>>,
7002    ///Property: Authored on
7003    #[serde(skip_serializing_if = "Option::is_none")]
7004    pub authored_at: Option<Vec<String>>,
7005    ///Property: Text
7006    #[serde(skip_serializing_if = "Option::is_none")]
7007    pub body_text: Option<Vec<String>>,
7008    ///Property: Detected companies
7009    #[serde(skip_serializing_if = "Option::is_none")]
7010    pub companies_mentioned: Option<Vec<String>>,
7011    ///Property: Checksum
7012    #[serde(skip_serializing_if = "Option::is_none")]
7013    pub content_hash: Option<Vec<String>>,
7014    ///Property: Country
7015    #[serde(skip_serializing_if = "Option::is_none")]
7016    pub country: Option<Vec<String>>,
7017    ///Property: Crawler
7018    #[serde(skip_serializing_if = "Option::is_none")]
7019    pub crawler: Option<Vec<String>>,
7020    ///Property: Created at
7021    #[serde(skip_serializing_if = "Option::is_none")]
7022    pub created_at: Option<Vec<String>>,
7023    ///Property: Date
7024    #[serde(skip_serializing_if = "Option::is_none")]
7025    pub date: Option<Vec<String>>,
7026    ///Property: Description
7027    #[serde(skip_serializing_if = "Option::is_none")]
7028    pub description: Option<Vec<String>>,
7029    ///Property: Detected country
7030    #[serde(skip_serializing_if = "Option::is_none")]
7031    pub detected_country: Option<Vec<String>>,
7032    ///Property: Detected language
7033    #[serde(skip_serializing_if = "Option::is_none")]
7034    pub detected_language: Option<Vec<String>>,
7035    ///Property: Detected e-mail addresses
7036    #[serde(skip_serializing_if = "Option::is_none")]
7037    pub email_mentioned: Option<Vec<String>>,
7038    ///Property: File encoding
7039    #[serde(skip_serializing_if = "Option::is_none")]
7040    pub encoding: Option<Vec<String>>,
7041    ///Property: File extension
7042    #[serde(skip_serializing_if = "Option::is_none")]
7043    pub extension: Option<Vec<String>>,
7044    ///Property: File name
7045    #[serde(default)]
7046    pub file_name: Vec<String>,
7047    ///Property: File size
7048    #[serde(
7049        skip_serializing_if = "Option::is_none",
7050        deserialize_with = "deserialize_opt_f64_vec",
7051        default
7052    )]
7053    pub file_size: Option<Vec<f64>>,
7054    ///Property: Generator
7055    #[serde(skip_serializing_if = "Option::is_none")]
7056    pub generator: Option<Vec<String>>,
7057    ///Property: Detected IBANs
7058    #[serde(skip_serializing_if = "Option::is_none")]
7059    pub iban_mentioned: Option<Vec<String>>,
7060    ///Property: Index text
7061    #[serde(skip_serializing_if = "Option::is_none")]
7062    pub index_text: Option<Vec<String>>,
7063    ///Property: Detected IP addresses
7064    #[serde(skip_serializing_if = "Option::is_none")]
7065    pub ip_mentioned: Option<Vec<String>>,
7066    ///Property: Keywords
7067    #[serde(skip_serializing_if = "Option::is_none")]
7068    pub keywords: Option<Vec<String>>,
7069    ///Property: Language
7070    #[serde(skip_serializing_if = "Option::is_none")]
7071    pub language: Option<Vec<String>>,
7072    ///Property: Detected locations
7073    #[serde(skip_serializing_if = "Option::is_none")]
7074    pub location_mentioned: Option<Vec<String>>,
7075    ///Property: Message ID
7076    #[serde(skip_serializing_if = "Option::is_none")]
7077    pub message_id: Option<Vec<String>>,
7078    ///Property: MIME type
7079    #[serde(skip_serializing_if = "Option::is_none")]
7080    pub mime_type: Option<Vec<String>>,
7081    ///Property: Modified on
7082    #[serde(skip_serializing_if = "Option::is_none")]
7083    pub modified_at: Option<Vec<String>>,
7084    ///Property: Name
7085    #[serde(default)]
7086    pub name: Vec<String>,
7087    ///Property: Detected names
7088    #[serde(skip_serializing_if = "Option::is_none")]
7089    pub names_mentioned: Option<Vec<String>>,
7090    ///Property: Notes
7091    #[serde(skip_serializing_if = "Option::is_none")]
7092    pub notes: Option<Vec<String>>,
7093    ///Property: Folder
7094    #[serde(skip_serializing_if = "Option::is_none")]
7095    pub parent: Option<Vec<String>>,
7096    ///Property: Detected people
7097    #[serde(skip_serializing_if = "Option::is_none")]
7098    pub people_mentioned: Option<Vec<String>>,
7099    ///Property: Detected phones
7100    #[serde(skip_serializing_if = "Option::is_none")]
7101    pub phone_mentioned: Option<Vec<String>>,
7102    ///Property: Previous name
7103    #[serde(skip_serializing_if = "Option::is_none")]
7104    pub previous_name: Option<Vec<String>>,
7105    ///Property: Processed at
7106    #[serde(skip_serializing_if = "Option::is_none")]
7107    pub processed_at: Option<Vec<String>>,
7108    ///Property: Processing agent
7109    #[serde(skip_serializing_if = "Option::is_none")]
7110    pub processing_agent: Option<Vec<String>>,
7111    ///Property: Processing error
7112    #[serde(skip_serializing_if = "Option::is_none")]
7113    pub processing_error: Option<Vec<String>>,
7114    ///Property: Processing status
7115    #[serde(skip_serializing_if = "Option::is_none")]
7116    pub processing_status: Option<Vec<String>>,
7117    ///Property: Program
7118    #[serde(skip_serializing_if = "Option::is_none")]
7119    pub program: Option<Vec<String>>,
7120    ///Property: Program ID
7121    #[serde(skip_serializing_if = "Option::is_none")]
7122    pub program_id: Option<Vec<String>>,
7123    ///Property: Source document
7124    #[serde(skip_serializing_if = "Option::is_none")]
7125    pub proof: Option<Vec<String>>,
7126    ///Property: Published on
7127    #[serde(skip_serializing_if = "Option::is_none")]
7128    pub published_at: Option<Vec<String>>,
7129    ///Property: Publishing source
7130    #[serde(skip_serializing_if = "Option::is_none")]
7131    pub publisher: Option<Vec<String>>,
7132    ///Property: Publishing source URL
7133    #[serde(skip_serializing_if = "Option::is_none")]
7134    pub publisher_url: Option<Vec<String>>,
7135    ///Property: Retrieved on
7136    #[serde(skip_serializing_if = "Option::is_none")]
7137    pub retrieved_at: Option<Vec<String>>,
7138    ///Property: Source link
7139    #[serde(skip_serializing_if = "Option::is_none")]
7140    pub source_url: Option<Vec<String>>,
7141    ///Property: Summary
7142    #[serde(skip_serializing_if = "Option::is_none")]
7143    pub summary: Option<Vec<String>>,
7144    ///Property: Title
7145    #[serde(skip_serializing_if = "Option::is_none")]
7146    pub title: Option<Vec<String>>,
7147    ///Property: Topics
7148    #[serde(skip_serializing_if = "Option::is_none")]
7149    pub topics: Option<Vec<String>>,
7150    ///Property: The language of the translated text
7151    #[serde(skip_serializing_if = "Option::is_none")]
7152    pub translated_language: Option<Vec<String>>,
7153    ///Property: Translated version of the body text
7154    #[serde(skip_serializing_if = "Option::is_none")]
7155    pub translated_text: Option<Vec<String>>,
7156    ///Property: Weak alias
7157    #[serde(skip_serializing_if = "Option::is_none")]
7158    pub weak_alias: Option<Vec<String>>,
7159    ///Property: Wikidata ID
7160    #[serde(skip_serializing_if = "Option::is_none")]
7161    pub wikidata_id: Option<Vec<String>>,
7162    ///Property: Wikipedia Article
7163    #[serde(skip_serializing_if = "Option::is_none")]
7164    pub wikipedia_url: Option<Vec<String>>,
7165}
7166impl Package {
7167    /// Create a new entity with the given ID
7168    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
7169    pub fn new(id: impl Into<String>) -> Self {
7170        Self {
7171            id: id.into(),
7172            schema: "Package".to_string(),
7173            address: None,
7174            address_entity: None,
7175            aleph_url: None,
7176            alias: None,
7177            ancestors: None,
7178            author: None,
7179            authored_at: None,
7180            body_text: None,
7181            companies_mentioned: None,
7182            content_hash: None,
7183            country: None,
7184            crawler: None,
7185            created_at: None,
7186            date: None,
7187            description: None,
7188            detected_country: None,
7189            detected_language: None,
7190            email_mentioned: None,
7191            encoding: None,
7192            extension: None,
7193            file_name: Vec::new(),
7194            file_size: None,
7195            generator: None,
7196            iban_mentioned: None,
7197            index_text: None,
7198            ip_mentioned: None,
7199            keywords: None,
7200            language: None,
7201            location_mentioned: None,
7202            message_id: None,
7203            mime_type: None,
7204            modified_at: None,
7205            name: Vec::new(),
7206            names_mentioned: None,
7207            notes: None,
7208            parent: None,
7209            people_mentioned: None,
7210            phone_mentioned: None,
7211            previous_name: None,
7212            processed_at: None,
7213            processing_agent: None,
7214            processing_error: None,
7215            processing_status: None,
7216            program: None,
7217            program_id: None,
7218            proof: None,
7219            published_at: None,
7220            publisher: None,
7221            publisher_url: None,
7222            retrieved_at: None,
7223            source_url: None,
7224            summary: None,
7225            title: None,
7226            topics: None,
7227            translated_language: None,
7228            translated_text: None,
7229            weak_alias: None,
7230            wikidata_id: None,
7231            wikipedia_url: None,
7232        }
7233    }
7234    /// Get the schema name
7235    pub fn schema_name() -> &'static str {
7236        "Package"
7237    }
7238}
7239///FTM Schema: Page
7240#[derive(Debug, Clone, Serialize, Deserialize)]
7241#[cfg_attr(feature = "builder", derive(Builder))]
7242#[serde(rename_all = "camelCase")]
7243pub struct Page {
7244    pub id: String,
7245    #[cfg_attr(feature = "builder", builder(default = "Page".to_string()))]
7246    pub schema: String,
7247    ///Property: Text
7248    #[serde(skip_serializing_if = "Option::is_none")]
7249    pub body_text: Option<Vec<String>>,
7250    ///Property: Detected language
7251    #[serde(skip_serializing_if = "Option::is_none")]
7252    pub detected_language: Option<Vec<String>>,
7253    ///Property: Document
7254    #[serde(skip_serializing_if = "Option::is_none")]
7255    pub document: Option<Vec<String>>,
7256    ///Property: Index
7257    #[serde(
7258        skip_serializing_if = "Option::is_none",
7259        deserialize_with = "deserialize_opt_f64_vec",
7260        default
7261    )]
7262    pub index: Option<Vec<f64>>,
7263    ///Property: Index text
7264    #[serde(skip_serializing_if = "Option::is_none")]
7265    pub index_text: Option<Vec<String>>,
7266    ///Property: Translated version of the body text
7267    #[serde(skip_serializing_if = "Option::is_none")]
7268    pub translated_text: Option<Vec<String>>,
7269    ///Property: The language of the translated text
7270    #[serde(skip_serializing_if = "Option::is_none")]
7271    pub translated_text_language: Option<Vec<String>>,
7272}
7273impl Page {
7274    /// Create a new entity with the given ID
7275    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
7276    pub fn new(id: impl Into<String>) -> Self {
7277        Self {
7278            id: id.into(),
7279            schema: "Page".to_string(),
7280            body_text: None,
7281            detected_language: None,
7282            document: None,
7283            index: None,
7284            index_text: None,
7285            translated_text: None,
7286            translated_text_language: None,
7287        }
7288    }
7289    /// Get the schema name
7290    pub fn schema_name() -> &'static str {
7291        "Page"
7292    }
7293}
7294///FTM Schema: Document
7295#[derive(Debug, Clone, Serialize, Deserialize)]
7296#[cfg_attr(feature = "builder", derive(Builder))]
7297#[serde(rename_all = "camelCase")]
7298pub struct Pages {
7299    pub id: String,
7300    #[cfg_attr(feature = "builder", builder(default = "Pages".to_string()))]
7301    pub schema: String,
7302    ///Property: Address
7303    #[serde(skip_serializing_if = "Option::is_none")]
7304    pub address: Option<Vec<String>>,
7305    ///Property: Address
7306    #[serde(skip_serializing_if = "Option::is_none")]
7307    pub address_entity: Option<Vec<String>>,
7308    ///Property: Aleph URL
7309    #[serde(skip_serializing_if = "Option::is_none")]
7310    pub aleph_url: Option<Vec<String>>,
7311    ///Property: Alias
7312    #[serde(skip_serializing_if = "Option::is_none")]
7313    pub alias: Option<Vec<String>>,
7314    ///Property: Ancestors
7315    #[serde(skip_serializing_if = "Option::is_none")]
7316    pub ancestors: Option<Vec<String>>,
7317    ///Property: Author
7318    #[serde(skip_serializing_if = "Option::is_none")]
7319    pub author: Option<Vec<String>>,
7320    ///Property: Authored on
7321    #[serde(skip_serializing_if = "Option::is_none")]
7322    pub authored_at: Option<Vec<String>>,
7323    ///Property: Text
7324    #[serde(skip_serializing_if = "Option::is_none")]
7325    pub body_text: Option<Vec<String>>,
7326    ///Property: Detected companies
7327    #[serde(skip_serializing_if = "Option::is_none")]
7328    pub companies_mentioned: Option<Vec<String>>,
7329    ///Property: Checksum
7330    #[serde(skip_serializing_if = "Option::is_none")]
7331    pub content_hash: Option<Vec<String>>,
7332    ///Property: Country
7333    #[serde(skip_serializing_if = "Option::is_none")]
7334    pub country: Option<Vec<String>>,
7335    ///Property: Crawler
7336    #[serde(skip_serializing_if = "Option::is_none")]
7337    pub crawler: Option<Vec<String>>,
7338    ///Property: Created at
7339    #[serde(skip_serializing_if = "Option::is_none")]
7340    pub created_at: Option<Vec<String>>,
7341    ///Property: Date
7342    #[serde(skip_serializing_if = "Option::is_none")]
7343    pub date: Option<Vec<String>>,
7344    ///Property: Description
7345    #[serde(skip_serializing_if = "Option::is_none")]
7346    pub description: Option<Vec<String>>,
7347    ///Property: Detected country
7348    #[serde(skip_serializing_if = "Option::is_none")]
7349    pub detected_country: Option<Vec<String>>,
7350    ///Property: Detected language
7351    #[serde(skip_serializing_if = "Option::is_none")]
7352    pub detected_language: Option<Vec<String>>,
7353    ///Property: Detected e-mail addresses
7354    #[serde(skip_serializing_if = "Option::is_none")]
7355    pub email_mentioned: Option<Vec<String>>,
7356    ///Property: File encoding
7357    #[serde(skip_serializing_if = "Option::is_none")]
7358    pub encoding: Option<Vec<String>>,
7359    ///Property: File extension
7360    #[serde(skip_serializing_if = "Option::is_none")]
7361    pub extension: Option<Vec<String>>,
7362    ///Property: File name
7363    #[serde(default)]
7364    pub file_name: Vec<String>,
7365    ///Property: File size
7366    #[serde(
7367        skip_serializing_if = "Option::is_none",
7368        deserialize_with = "deserialize_opt_f64_vec",
7369        default
7370    )]
7371    pub file_size: Option<Vec<f64>>,
7372    ///Property: Generator
7373    #[serde(skip_serializing_if = "Option::is_none")]
7374    pub generator: Option<Vec<String>>,
7375    ///Property: Detected IBANs
7376    #[serde(skip_serializing_if = "Option::is_none")]
7377    pub iban_mentioned: Option<Vec<String>>,
7378    ///Property: Index text
7379    #[serde(skip_serializing_if = "Option::is_none")]
7380    pub index_text: Option<Vec<String>>,
7381    ///Property: Detected IP addresses
7382    #[serde(skip_serializing_if = "Option::is_none")]
7383    pub ip_mentioned: Option<Vec<String>>,
7384    ///Property: Keywords
7385    #[serde(skip_serializing_if = "Option::is_none")]
7386    pub keywords: Option<Vec<String>>,
7387    ///Property: Language
7388    #[serde(skip_serializing_if = "Option::is_none")]
7389    pub language: Option<Vec<String>>,
7390    ///Property: Detected locations
7391    #[serde(skip_serializing_if = "Option::is_none")]
7392    pub location_mentioned: Option<Vec<String>>,
7393    ///Property: Message ID
7394    #[serde(skip_serializing_if = "Option::is_none")]
7395    pub message_id: Option<Vec<String>>,
7396    ///Property: MIME type
7397    #[serde(skip_serializing_if = "Option::is_none")]
7398    pub mime_type: Option<Vec<String>>,
7399    ///Property: Modified on
7400    #[serde(skip_serializing_if = "Option::is_none")]
7401    pub modified_at: Option<Vec<String>>,
7402    ///Property: Name
7403    #[serde(default)]
7404    pub name: Vec<String>,
7405    ///Property: Detected names
7406    #[serde(skip_serializing_if = "Option::is_none")]
7407    pub names_mentioned: Option<Vec<String>>,
7408    ///Property: Notes
7409    #[serde(skip_serializing_if = "Option::is_none")]
7410    pub notes: Option<Vec<String>>,
7411    ///Property: Folder
7412    #[serde(skip_serializing_if = "Option::is_none")]
7413    pub parent: Option<Vec<String>>,
7414    ///Property: PDF alternative version checksum
7415    #[serde(skip_serializing_if = "Option::is_none")]
7416    pub pdf_hash: Option<Vec<String>>,
7417    ///Property: Detected people
7418    #[serde(skip_serializing_if = "Option::is_none")]
7419    pub people_mentioned: Option<Vec<String>>,
7420    ///Property: Detected phones
7421    #[serde(skip_serializing_if = "Option::is_none")]
7422    pub phone_mentioned: Option<Vec<String>>,
7423    ///Property: Previous name
7424    #[serde(skip_serializing_if = "Option::is_none")]
7425    pub previous_name: Option<Vec<String>>,
7426    ///Property: Processed at
7427    #[serde(skip_serializing_if = "Option::is_none")]
7428    pub processed_at: Option<Vec<String>>,
7429    ///Property: Processing agent
7430    #[serde(skip_serializing_if = "Option::is_none")]
7431    pub processing_agent: Option<Vec<String>>,
7432    ///Property: Processing error
7433    #[serde(skip_serializing_if = "Option::is_none")]
7434    pub processing_error: Option<Vec<String>>,
7435    ///Property: Processing status
7436    #[serde(skip_serializing_if = "Option::is_none")]
7437    pub processing_status: Option<Vec<String>>,
7438    ///Property: Program
7439    #[serde(skip_serializing_if = "Option::is_none")]
7440    pub program: Option<Vec<String>>,
7441    ///Property: Program ID
7442    #[serde(skip_serializing_if = "Option::is_none")]
7443    pub program_id: Option<Vec<String>>,
7444    ///Property: Source document
7445    #[serde(skip_serializing_if = "Option::is_none")]
7446    pub proof: Option<Vec<String>>,
7447    ///Property: Published on
7448    #[serde(skip_serializing_if = "Option::is_none")]
7449    pub published_at: Option<Vec<String>>,
7450    ///Property: Publishing source
7451    #[serde(skip_serializing_if = "Option::is_none")]
7452    pub publisher: Option<Vec<String>>,
7453    ///Property: Publishing source URL
7454    #[serde(skip_serializing_if = "Option::is_none")]
7455    pub publisher_url: Option<Vec<String>>,
7456    ///Property: Retrieved on
7457    #[serde(skip_serializing_if = "Option::is_none")]
7458    pub retrieved_at: Option<Vec<String>>,
7459    ///Property: Source link
7460    #[serde(skip_serializing_if = "Option::is_none")]
7461    pub source_url: Option<Vec<String>>,
7462    ///Property: Summary
7463    #[serde(skip_serializing_if = "Option::is_none")]
7464    pub summary: Option<Vec<String>>,
7465    ///Property: Title
7466    #[serde(skip_serializing_if = "Option::is_none")]
7467    pub title: Option<Vec<String>>,
7468    ///Property: Topics
7469    #[serde(skip_serializing_if = "Option::is_none")]
7470    pub topics: Option<Vec<String>>,
7471    ///Property: The language of the translated text
7472    #[serde(skip_serializing_if = "Option::is_none")]
7473    pub translated_language: Option<Vec<String>>,
7474    ///Property: Translated version of the body text
7475    #[serde(skip_serializing_if = "Option::is_none")]
7476    pub translated_text: Option<Vec<String>>,
7477    ///Property: Weak alias
7478    #[serde(skip_serializing_if = "Option::is_none")]
7479    pub weak_alias: Option<Vec<String>>,
7480    ///Property: Wikidata ID
7481    #[serde(skip_serializing_if = "Option::is_none")]
7482    pub wikidata_id: Option<Vec<String>>,
7483    ///Property: Wikipedia Article
7484    #[serde(skip_serializing_if = "Option::is_none")]
7485    pub wikipedia_url: Option<Vec<String>>,
7486}
7487impl Pages {
7488    /// Create a new entity with the given ID
7489    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
7490    pub fn new(id: impl Into<String>) -> Self {
7491        Self {
7492            id: id.into(),
7493            schema: "Pages".to_string(),
7494            address: None,
7495            address_entity: None,
7496            aleph_url: None,
7497            alias: None,
7498            ancestors: None,
7499            author: None,
7500            authored_at: None,
7501            body_text: None,
7502            companies_mentioned: None,
7503            content_hash: None,
7504            country: None,
7505            crawler: None,
7506            created_at: None,
7507            date: None,
7508            description: None,
7509            detected_country: None,
7510            detected_language: None,
7511            email_mentioned: None,
7512            encoding: None,
7513            extension: None,
7514            file_name: Vec::new(),
7515            file_size: None,
7516            generator: None,
7517            iban_mentioned: None,
7518            index_text: None,
7519            ip_mentioned: None,
7520            keywords: None,
7521            language: None,
7522            location_mentioned: None,
7523            message_id: None,
7524            mime_type: None,
7525            modified_at: None,
7526            name: Vec::new(),
7527            names_mentioned: None,
7528            notes: None,
7529            parent: None,
7530            pdf_hash: None,
7531            people_mentioned: None,
7532            phone_mentioned: None,
7533            previous_name: None,
7534            processed_at: None,
7535            processing_agent: None,
7536            processing_error: None,
7537            processing_status: None,
7538            program: None,
7539            program_id: None,
7540            proof: None,
7541            published_at: None,
7542            publisher: None,
7543            publisher_url: None,
7544            retrieved_at: None,
7545            source_url: None,
7546            summary: None,
7547            title: None,
7548            topics: None,
7549            translated_language: None,
7550            translated_text: None,
7551            weak_alias: None,
7552            wikidata_id: None,
7553            wikipedia_url: None,
7554        }
7555    }
7556    /// Get the schema name
7557    pub fn schema_name() -> &'static str {
7558        "Pages"
7559    }
7560}
7561///FTM Schema: Passport
7562#[derive(Debug, Clone, Serialize, Deserialize)]
7563#[cfg_attr(feature = "builder", derive(Builder))]
7564#[serde(rename_all = "camelCase")]
7565pub struct Passport {
7566    pub id: String,
7567    #[cfg_attr(feature = "builder", builder(default = "Passport".to_string()))]
7568    pub schema: String,
7569    ///Property: Aleph URL
7570    #[serde(skip_serializing_if = "Option::is_none")]
7571    pub aleph_url: Option<Vec<String>>,
7572    ///Property: Authority
7573    #[serde(skip_serializing_if = "Option::is_none")]
7574    pub authority: Option<Vec<String>>,
7575    ///Property: Birth date
7576    #[serde(skip_serializing_if = "Option::is_none")]
7577    pub birth_date: Option<Vec<String>>,
7578    ///Property: Place of birth
7579    #[serde(skip_serializing_if = "Option::is_none")]
7580    pub birth_place: Option<Vec<String>>,
7581    ///Property: Country
7582    #[serde(skip_serializing_if = "Option::is_none")]
7583    pub country: Option<Vec<String>>,
7584    ///Property: Date
7585    #[serde(skip_serializing_if = "Option::is_none")]
7586    pub date: Option<Vec<String>>,
7587    ///Property: Description
7588    #[serde(skip_serializing_if = "Option::is_none")]
7589    pub description: Option<Vec<String>>,
7590    ///Property: End date
7591    #[serde(skip_serializing_if = "Option::is_none")]
7592    pub end_date: Option<Vec<String>>,
7593    ///Property: Gender
7594    #[serde(skip_serializing_if = "Option::is_none")]
7595    pub gender: Option<Vec<String>>,
7596    ///Property: Given name
7597    #[serde(skip_serializing_if = "Option::is_none")]
7598    pub given_name: Option<Vec<String>>,
7599    ///Property: Identification holder
7600    #[serde(default)]
7601    pub holder: Vec<String>,
7602    ///Property: Index text
7603    #[serde(skip_serializing_if = "Option::is_none")]
7604    pub index_text: Option<Vec<String>>,
7605    ///Property: Modified on
7606    #[serde(skip_serializing_if = "Option::is_none")]
7607    pub modified_at: Option<Vec<String>>,
7608    ///Property: Detected names
7609    #[serde(skip_serializing_if = "Option::is_none")]
7610    pub names_mentioned: Option<Vec<String>>,
7611    ///Property: Document number
7612    #[serde(default)]
7613    pub number: Vec<String>,
7614    ///Property: Passport number
7615    #[serde(skip_serializing_if = "Option::is_none")]
7616    pub passport_number: Option<Vec<String>>,
7617    ///Property: Personal number
7618    #[serde(skip_serializing_if = "Option::is_none")]
7619    pub personal_number: Option<Vec<String>>,
7620    ///Property: Source document
7621    #[serde(skip_serializing_if = "Option::is_none")]
7622    pub proof: Option<Vec<String>>,
7623    ///Property: Publishing source
7624    #[serde(skip_serializing_if = "Option::is_none")]
7625    pub publisher: Option<Vec<String>>,
7626    ///Property: Publishing source URL
7627    #[serde(skip_serializing_if = "Option::is_none")]
7628    pub publisher_url: Option<Vec<String>>,
7629    ///Property: Record ID
7630    #[serde(skip_serializing_if = "Option::is_none")]
7631    pub record_id: Option<Vec<String>>,
7632    ///Property: Retrieved on
7633    #[serde(skip_serializing_if = "Option::is_none")]
7634    pub retrieved_at: Option<Vec<String>>,
7635    ///Property: Source link
7636    #[serde(skip_serializing_if = "Option::is_none")]
7637    pub source_url: Option<Vec<String>>,
7638    ///Property: Start date
7639    #[serde(skip_serializing_if = "Option::is_none")]
7640    pub start_date: Option<Vec<String>>,
7641    ///Property: Summary
7642    #[serde(skip_serializing_if = "Option::is_none")]
7643    pub summary: Option<Vec<String>>,
7644    ///Property: Surname
7645    #[serde(skip_serializing_if = "Option::is_none")]
7646    pub surname: Option<Vec<String>>,
7647    ///Property: Type
7648    #[serde(skip_serializing_if = "Option::is_none")]
7649    pub type_: Option<Vec<String>>,
7650}
7651impl Passport {
7652    /// Create a new entity with the given ID
7653    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
7654    pub fn new(id: impl Into<String>) -> Self {
7655        Self {
7656            id: id.into(),
7657            schema: "Passport".to_string(),
7658            aleph_url: None,
7659            authority: None,
7660            birth_date: None,
7661            birth_place: None,
7662            country: None,
7663            date: None,
7664            description: None,
7665            end_date: None,
7666            gender: None,
7667            given_name: None,
7668            holder: Vec::new(),
7669            index_text: None,
7670            modified_at: None,
7671            names_mentioned: None,
7672            number: Vec::new(),
7673            passport_number: None,
7674            personal_number: None,
7675            proof: None,
7676            publisher: None,
7677            publisher_url: None,
7678            record_id: None,
7679            retrieved_at: None,
7680            source_url: None,
7681            start_date: None,
7682            summary: None,
7683            surname: None,
7684            type_: None,
7685        }
7686    }
7687    /// Get the schema name
7688    pub fn schema_name() -> &'static str {
7689        "Passport"
7690    }
7691}
7692///FTM Schema: Payment
7693#[derive(Debug, Clone, Serialize, Deserialize)]
7694#[cfg_attr(feature = "builder", derive(Builder))]
7695#[serde(rename_all = "camelCase")]
7696pub struct Payment {
7697    pub id: String,
7698    #[cfg_attr(feature = "builder", builder(default = "Payment".to_string()))]
7699    pub schema: String,
7700    ///Property: Aleph URL
7701    #[serde(skip_serializing_if = "Option::is_none")]
7702    pub aleph_url: Option<Vec<String>>,
7703    ///Property: Amount
7704    #[serde(
7705        skip_serializing_if = "Option::is_none",
7706        deserialize_with = "deserialize_opt_f64_vec",
7707        default
7708    )]
7709    pub amount: Option<Vec<f64>>,
7710    ///Property: Amount in EUR
7711    #[serde(
7712        skip_serializing_if = "Option::is_none",
7713        deserialize_with = "deserialize_opt_f64_vec",
7714        default
7715    )]
7716    pub amount_eur: Option<Vec<f64>>,
7717    ///Property: Amount in USD
7718    #[serde(
7719        skip_serializing_if = "Option::is_none",
7720        deserialize_with = "deserialize_opt_f64_vec",
7721        default
7722    )]
7723    pub amount_usd: Option<Vec<f64>>,
7724    ///Property: Beneficiary
7725    #[serde(default)]
7726    pub beneficiary: Vec<String>,
7727    ///Property: Beneficiary bank account
7728    #[serde(skip_serializing_if = "Option::is_none")]
7729    pub beneficiary_account: Option<Vec<String>>,
7730    ///Property: Contract
7731    #[serde(skip_serializing_if = "Option::is_none")]
7732    pub contract: Option<Vec<String>>,
7733    ///Property: Currency
7734    #[serde(skip_serializing_if = "Option::is_none")]
7735    pub currency: Option<Vec<String>>,
7736    ///Property: Date
7737    #[serde(skip_serializing_if = "Option::is_none")]
7738    pub date: Option<Vec<String>>,
7739    ///Property: Description
7740    #[serde(skip_serializing_if = "Option::is_none")]
7741    pub description: Option<Vec<String>>,
7742    ///Property: End date
7743    #[serde(skip_serializing_if = "Option::is_none")]
7744    pub end_date: Option<Vec<String>>,
7745    ///Property: Index text
7746    #[serde(skip_serializing_if = "Option::is_none")]
7747    pub index_text: Option<Vec<String>>,
7748    ///Property: Modified on
7749    #[serde(skip_serializing_if = "Option::is_none")]
7750    pub modified_at: Option<Vec<String>>,
7751    ///Property: Detected names
7752    #[serde(skip_serializing_if = "Option::is_none")]
7753    pub names_mentioned: Option<Vec<String>>,
7754    ///Property: Payer
7755    #[serde(default)]
7756    pub payer: Vec<String>,
7757    ///Property: Payer bank account
7758    #[serde(skip_serializing_if = "Option::is_none")]
7759    pub payer_account: Option<Vec<String>>,
7760    ///Property: Payment programme
7761    #[serde(skip_serializing_if = "Option::is_none")]
7762    pub programme: Option<Vec<String>>,
7763    ///Property: Project
7764    #[serde(skip_serializing_if = "Option::is_none")]
7765    pub project: Option<Vec<String>>,
7766    ///Property: Source document
7767    #[serde(skip_serializing_if = "Option::is_none")]
7768    pub proof: Option<Vec<String>>,
7769    ///Property: Publishing source
7770    #[serde(skip_serializing_if = "Option::is_none")]
7771    pub publisher: Option<Vec<String>>,
7772    ///Property: Publishing source URL
7773    #[serde(skip_serializing_if = "Option::is_none")]
7774    pub publisher_url: Option<Vec<String>>,
7775    ///Property: Payment purpose
7776    #[serde(skip_serializing_if = "Option::is_none")]
7777    pub purpose: Option<Vec<String>>,
7778    ///Property: Record ID
7779    #[serde(skip_serializing_if = "Option::is_none")]
7780    pub record_id: Option<Vec<String>>,
7781    ///Property: Retrieved on
7782    #[serde(skip_serializing_if = "Option::is_none")]
7783    pub retrieved_at: Option<Vec<String>>,
7784    ///Property: Sequence number
7785    #[serde(skip_serializing_if = "Option::is_none")]
7786    pub sequence_number: Option<Vec<String>>,
7787    ///Property: Source link
7788    #[serde(skip_serializing_if = "Option::is_none")]
7789    pub source_url: Option<Vec<String>>,
7790    ///Property: Start date
7791    #[serde(skip_serializing_if = "Option::is_none")]
7792    pub start_date: Option<Vec<String>>,
7793    ///Property: Summary
7794    #[serde(skip_serializing_if = "Option::is_none")]
7795    pub summary: Option<Vec<String>>,
7796    ///Property: Transaction number
7797    #[serde(skip_serializing_if = "Option::is_none")]
7798    pub transaction_number: Option<Vec<String>>,
7799}
7800impl Payment {
7801    /// Create a new entity with the given ID
7802    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
7803    pub fn new(id: impl Into<String>) -> Self {
7804        Self {
7805            id: id.into(),
7806            schema: "Payment".to_string(),
7807            aleph_url: None,
7808            amount: None,
7809            amount_eur: None,
7810            amount_usd: None,
7811            beneficiary: Vec::new(),
7812            beneficiary_account: None,
7813            contract: None,
7814            currency: None,
7815            date: None,
7816            description: None,
7817            end_date: None,
7818            index_text: None,
7819            modified_at: None,
7820            names_mentioned: None,
7821            payer: Vec::new(),
7822            payer_account: None,
7823            programme: None,
7824            project: None,
7825            proof: None,
7826            publisher: None,
7827            publisher_url: None,
7828            purpose: None,
7829            record_id: None,
7830            retrieved_at: None,
7831            sequence_number: None,
7832            source_url: None,
7833            start_date: None,
7834            summary: None,
7835            transaction_number: None,
7836        }
7837    }
7838    /// Get the schema name
7839    pub fn schema_name() -> &'static str {
7840        "Payment"
7841    }
7842}
7843///FTM Schema: Person
7844#[derive(Debug, Clone, Serialize, Deserialize)]
7845#[cfg_attr(feature = "builder", derive(Builder))]
7846#[serde(rename_all = "camelCase")]
7847pub struct Person {
7848    pub id: String,
7849    #[cfg_attr(feature = "builder", builder(default = "Person".to_string()))]
7850    pub schema: String,
7851    ///Property: Abbreviation
7852    #[serde(skip_serializing_if = "Option::is_none")]
7853    pub abbreviation: Option<Vec<String>>,
7854    ///Property: Address
7855    #[serde(skip_serializing_if = "Option::is_none")]
7856    pub address: Option<Vec<String>>,
7857    ///Property: Address
7858    #[serde(skip_serializing_if = "Option::is_none")]
7859    pub address_entity: Option<Vec<String>>,
7860    ///Property: Aleph URL
7861    #[serde(skip_serializing_if = "Option::is_none")]
7862    pub aleph_url: Option<Vec<String>>,
7863    ///Property: Alias
7864    #[serde(skip_serializing_if = "Option::is_none")]
7865    pub alias: Option<Vec<String>>,
7866    ///Property: Physical appearance
7867    #[serde(skip_serializing_if = "Option::is_none")]
7868    pub appearance: Option<Vec<String>>,
7869    ///Property: Country of birth
7870    #[serde(skip_serializing_if = "Option::is_none")]
7871    pub birth_country: Option<Vec<String>>,
7872    ///Property: Birth date
7873    #[serde(skip_serializing_if = "Option::is_none")]
7874    pub birth_date: Option<Vec<String>>,
7875    ///Property: Place of birth
7876    #[serde(skip_serializing_if = "Option::is_none")]
7877    pub birth_place: Option<Vec<String>>,
7878    ///Property: BrightQuery ID
7879    #[serde(skip_serializing_if = "Option::is_none")]
7880    pub bright_query_id: Option<Vec<String>>,
7881    ///Property: BrightQuery Organization ID
7882    #[serde(skip_serializing_if = "Option::is_none")]
7883    pub bright_query_org_id: Option<Vec<String>>,
7884    ///Property: Bureau van Dijk ID
7885    #[serde(skip_serializing_if = "Option::is_none")]
7886    pub bvd_id: Option<Vec<String>>,
7887    ///Property: Citizenship
7888    #[serde(skip_serializing_if = "Option::is_none")]
7889    pub citizenship: Option<Vec<String>>,
7890    ///Property: Classification
7891    #[serde(skip_serializing_if = "Option::is_none")]
7892    pub classification: Option<Vec<String>>,
7893    ///Property: Country
7894    #[serde(skip_serializing_if = "Option::is_none")]
7895    pub country: Option<Vec<String>>,
7896    ///Property: Created at
7897    #[serde(skip_serializing_if = "Option::is_none")]
7898    pub created_at: Option<Vec<String>>,
7899    ///Property: Death date
7900    #[serde(skip_serializing_if = "Option::is_none")]
7901    pub death_date: Option<Vec<String>>,
7902    ///Property: Description
7903    #[serde(skip_serializing_if = "Option::is_none")]
7904    pub description: Option<Vec<String>>,
7905    ///Property: Dissolution date
7906    #[serde(skip_serializing_if = "Option::is_none")]
7907    pub dissolution_date: Option<Vec<String>>,
7908    ///Property: DUNS
7909    #[serde(skip_serializing_if = "Option::is_none")]
7910    pub duns_code: Option<Vec<String>>,
7911    ///Property: Education
7912    #[serde(skip_serializing_if = "Option::is_none")]
7913    pub education: Option<Vec<String>>,
7914    ///Property: E-Mail
7915    #[serde(skip_serializing_if = "Option::is_none")]
7916    pub email: Option<Vec<String>>,
7917    ///Property: Ethnicity
7918    #[serde(skip_serializing_if = "Option::is_none")]
7919    pub ethnicity: Option<Vec<String>>,
7920    ///Property: Eye color
7921    #[serde(skip_serializing_if = "Option::is_none")]
7922    pub eye_color: Option<Vec<String>>,
7923    ///Property: Patronymic
7924    #[serde(skip_serializing_if = "Option::is_none")]
7925    pub father_name: Option<Vec<String>>,
7926    ///Property: First name
7927    #[serde(skip_serializing_if = "Option::is_none")]
7928    pub first_name: Option<Vec<String>>,
7929    ///Property: Gender
7930    #[serde(skip_serializing_if = "Option::is_none")]
7931    pub gender: Option<Vec<String>>,
7932    ///Property: Hair color
7933    #[serde(skip_serializing_if = "Option::is_none")]
7934    pub hair_color: Option<Vec<String>>,
7935    ///Property: Height
7936    #[serde(
7937        skip_serializing_if = "Option::is_none",
7938        deserialize_with = "deserialize_opt_f64_vec",
7939        default
7940    )]
7941    pub height: Option<Vec<f64>>,
7942    ///Property: ICIJ ID
7943    #[serde(skip_serializing_if = "Option::is_none")]
7944    pub icij_id: Option<Vec<String>>,
7945    ///Property: ID Number
7946    #[serde(skip_serializing_if = "Option::is_none")]
7947    pub id_number: Option<Vec<String>>,
7948    ///Property: Incorporation date
7949    #[serde(skip_serializing_if = "Option::is_none")]
7950    pub incorporation_date: Option<Vec<String>>,
7951    ///Property: Index text
7952    #[serde(skip_serializing_if = "Option::is_none")]
7953    pub index_text: Option<Vec<String>>,
7954    ///Property: INN
7955    #[serde(skip_serializing_if = "Option::is_none")]
7956    pub inn_code: Option<Vec<String>>,
7957    ///Property: Jurisdiction
7958    #[serde(skip_serializing_if = "Option::is_none")]
7959    pub jurisdiction: Option<Vec<String>>,
7960    ///Property: Keywords
7961    #[serde(skip_serializing_if = "Option::is_none")]
7962    pub keywords: Option<Vec<String>>,
7963    ///Property: Last name
7964    #[serde(skip_serializing_if = "Option::is_none")]
7965    pub last_name: Option<Vec<String>>,
7966    ///Property: Legal form
7967    #[serde(skip_serializing_if = "Option::is_none")]
7968    pub legal_form: Option<Vec<String>>,
7969    ///Property: LEI
7970    #[serde(skip_serializing_if = "Option::is_none")]
7971    pub lei_code: Option<Vec<String>>,
7972    ///Property: License Number
7973    #[serde(skip_serializing_if = "Option::is_none")]
7974    pub license_number: Option<Vec<String>>,
7975    ///Property: Country of origin
7976    #[serde(skip_serializing_if = "Option::is_none")]
7977    pub main_country: Option<Vec<String>>,
7978    ///Property: Middle name
7979    #[serde(skip_serializing_if = "Option::is_none")]
7980    pub middle_name: Option<Vec<String>>,
7981    ///Property: Modified on
7982    #[serde(skip_serializing_if = "Option::is_none")]
7983    pub modified_at: Option<Vec<String>>,
7984    ///Property: Matronymic
7985    #[serde(skip_serializing_if = "Option::is_none")]
7986    pub mother_name: Option<Vec<String>>,
7987    ///Property: Name
7988    #[serde(default)]
7989    pub name: Vec<String>,
7990    ///Property: Name suffix
7991    #[serde(skip_serializing_if = "Option::is_none")]
7992    pub name_suffix: Option<Vec<String>>,
7993    ///Property: Nationality
7994    #[serde(skip_serializing_if = "Option::is_none")]
7995    pub nationality: Option<Vec<String>>,
7996    ///Property: Notes
7997    #[serde(skip_serializing_if = "Option::is_none")]
7998    pub notes: Option<Vec<String>>,
7999    ///Property: NPI
8000    #[serde(skip_serializing_if = "Option::is_none")]
8001    pub npi_code: Option<Vec<String>>,
8002    ///Property: OGRN
8003    #[serde(skip_serializing_if = "Option::is_none")]
8004    pub ogrn_code: Option<Vec<String>>,
8005    ///Property: OKPO
8006    #[serde(skip_serializing_if = "Option::is_none")]
8007    pub okpo_code: Option<Vec<String>>,
8008    ///Property: OpenCorporates URL
8009    #[serde(skip_serializing_if = "Option::is_none")]
8010    pub opencorporates_url: Option<Vec<String>>,
8011    ///Property: Parent company
8012    #[serde(skip_serializing_if = "Option::is_none")]
8013    pub parent: Option<Vec<String>>,
8014    ///Property: Passport number
8015    #[serde(skip_serializing_if = "Option::is_none")]
8016    pub passport_number: Option<Vec<String>>,
8017    ///Property: Phone
8018    #[serde(skip_serializing_if = "Option::is_none")]
8019    pub phone: Option<Vec<String>>,
8020    ///Property: Political association
8021    #[serde(skip_serializing_if = "Option::is_none")]
8022    pub political: Option<Vec<String>>,
8023    ///Property: Position
8024    #[serde(skip_serializing_if = "Option::is_none")]
8025    pub position: Option<Vec<String>>,
8026    ///Property: Previous name
8027    #[serde(skip_serializing_if = "Option::is_none")]
8028    pub previous_name: Option<Vec<String>>,
8029    ///Property: Profession
8030    #[serde(skip_serializing_if = "Option::is_none")]
8031    pub profession: Option<Vec<String>>,
8032    ///Property: Program
8033    #[serde(skip_serializing_if = "Option::is_none")]
8034    pub program: Option<Vec<String>>,
8035    ///Property: Program ID
8036    #[serde(skip_serializing_if = "Option::is_none")]
8037    pub program_id: Option<Vec<String>>,
8038    ///Property: Source document
8039    #[serde(skip_serializing_if = "Option::is_none")]
8040    pub proof: Option<Vec<String>>,
8041    ///Property: Publishing source
8042    #[serde(skip_serializing_if = "Option::is_none")]
8043    pub publisher: Option<Vec<String>>,
8044    ///Property: Publishing source URL
8045    #[serde(skip_serializing_if = "Option::is_none")]
8046    pub publisher_url: Option<Vec<String>>,
8047    ///Property: Registration number
8048    #[serde(skip_serializing_if = "Option::is_none")]
8049    pub registration_number: Option<Vec<String>>,
8050    ///Property: Religion
8051    #[serde(skip_serializing_if = "Option::is_none")]
8052    pub religion: Option<Vec<String>>,
8053    ///Property: Retrieved on
8054    #[serde(skip_serializing_if = "Option::is_none")]
8055    pub retrieved_at: Option<Vec<String>>,
8056    ///Property: Sayari Entity ID
8057    #[serde(skip_serializing_if = "Option::is_none")]
8058    pub sayari_id: Option<Vec<String>>,
8059    ///Property: Second name
8060    #[serde(skip_serializing_if = "Option::is_none")]
8061    pub second_name: Option<Vec<String>>,
8062    ///Property: Sector
8063    #[serde(skip_serializing_if = "Option::is_none")]
8064    pub sector: Option<Vec<String>>,
8065    ///Property: Social security number
8066    #[serde(skip_serializing_if = "Option::is_none")]
8067    pub social_security_number: Option<Vec<String>>,
8068    ///Property: Source link
8069    #[serde(skip_serializing_if = "Option::is_none")]
8070    pub source_url: Option<Vec<String>>,
8071    ///Property: Spoken language
8072    #[serde(skip_serializing_if = "Option::is_none")]
8073    pub spoken_language: Option<Vec<String>>,
8074    ///Property: Status
8075    #[serde(skip_serializing_if = "Option::is_none")]
8076    pub status: Option<Vec<String>>,
8077    ///Property: Summary
8078    #[serde(skip_serializing_if = "Option::is_none")]
8079    pub summary: Option<Vec<String>>,
8080    ///Property: SWIFT/BIC
8081    #[serde(skip_serializing_if = "Option::is_none")]
8082    pub swift_bic: Option<Vec<String>>,
8083    ///Property: Tax Number
8084    #[serde(skip_serializing_if = "Option::is_none")]
8085    pub tax_number: Option<Vec<String>>,
8086    ///Property: Tax status
8087    #[serde(skip_serializing_if = "Option::is_none")]
8088    pub tax_status: Option<Vec<String>>,
8089    ///Property: Title
8090    #[serde(skip_serializing_if = "Option::is_none")]
8091    pub title: Option<Vec<String>>,
8092    ///Property: Topics
8093    #[serde(skip_serializing_if = "Option::is_none")]
8094    pub topics: Option<Vec<String>>,
8095    ///Property: Unique Entity ID
8096    #[serde(skip_serializing_if = "Option::is_none")]
8097    pub unique_entity_id: Option<Vec<String>>,
8098    ///Property: USCC
8099    #[serde(skip_serializing_if = "Option::is_none")]
8100    pub usc_code: Option<Vec<String>>,
8101    ///Property: V.A.T. Identifier
8102    #[serde(skip_serializing_if = "Option::is_none")]
8103    pub vat_code: Option<Vec<String>>,
8104    ///Property: Weak alias
8105    #[serde(skip_serializing_if = "Option::is_none")]
8106    pub weak_alias: Option<Vec<String>>,
8107    ///Property: Website
8108    #[serde(skip_serializing_if = "Option::is_none")]
8109    pub website: Option<Vec<String>>,
8110    ///Property: Weight
8111    #[serde(
8112        skip_serializing_if = "Option::is_none",
8113        deserialize_with = "deserialize_opt_f64_vec",
8114        default
8115    )]
8116    pub weight: Option<Vec<f64>>,
8117    ///Property: Wikidata ID
8118    #[serde(skip_serializing_if = "Option::is_none")]
8119    pub wikidata_id: Option<Vec<String>>,
8120    ///Property: Wikipedia Article
8121    #[serde(skip_serializing_if = "Option::is_none")]
8122    pub wikipedia_url: Option<Vec<String>>,
8123}
8124impl Person {
8125    /// Create a new entity with the given ID
8126    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
8127    pub fn new(id: impl Into<String>) -> Self {
8128        Self {
8129            id: id.into(),
8130            schema: "Person".to_string(),
8131            abbreviation: None,
8132            address: None,
8133            address_entity: None,
8134            aleph_url: None,
8135            alias: None,
8136            appearance: None,
8137            birth_country: None,
8138            birth_date: None,
8139            birth_place: None,
8140            bright_query_id: None,
8141            bright_query_org_id: None,
8142            bvd_id: None,
8143            citizenship: None,
8144            classification: None,
8145            country: None,
8146            created_at: None,
8147            death_date: None,
8148            description: None,
8149            dissolution_date: None,
8150            duns_code: None,
8151            education: None,
8152            email: None,
8153            ethnicity: None,
8154            eye_color: None,
8155            father_name: None,
8156            first_name: None,
8157            gender: None,
8158            hair_color: None,
8159            height: None,
8160            icij_id: None,
8161            id_number: None,
8162            incorporation_date: None,
8163            index_text: None,
8164            inn_code: None,
8165            jurisdiction: None,
8166            keywords: None,
8167            last_name: None,
8168            legal_form: None,
8169            lei_code: None,
8170            license_number: None,
8171            main_country: None,
8172            middle_name: None,
8173            modified_at: None,
8174            mother_name: None,
8175            name: Vec::new(),
8176            name_suffix: None,
8177            nationality: None,
8178            notes: None,
8179            npi_code: None,
8180            ogrn_code: None,
8181            okpo_code: None,
8182            opencorporates_url: None,
8183            parent: None,
8184            passport_number: None,
8185            phone: None,
8186            political: None,
8187            position: None,
8188            previous_name: None,
8189            profession: None,
8190            program: None,
8191            program_id: None,
8192            proof: None,
8193            publisher: None,
8194            publisher_url: None,
8195            registration_number: None,
8196            religion: None,
8197            retrieved_at: None,
8198            sayari_id: None,
8199            second_name: None,
8200            sector: None,
8201            social_security_number: None,
8202            source_url: None,
8203            spoken_language: None,
8204            status: None,
8205            summary: None,
8206            swift_bic: None,
8207            tax_number: None,
8208            tax_status: None,
8209            title: None,
8210            topics: None,
8211            unique_entity_id: None,
8212            usc_code: None,
8213            vat_code: None,
8214            weak_alias: None,
8215            website: None,
8216            weight: None,
8217            wikidata_id: None,
8218            wikipedia_url: None,
8219        }
8220    }
8221    /// Get the schema name
8222    pub fn schema_name() -> &'static str {
8223        "Person"
8224    }
8225}
8226///FTM Schema: Text file
8227#[derive(Debug, Clone, Serialize, Deserialize)]
8228#[cfg_attr(feature = "builder", derive(Builder))]
8229#[serde(rename_all = "camelCase")]
8230pub struct PlainText {
8231    pub id: String,
8232    #[cfg_attr(feature = "builder", builder(default = "PlainText".to_string()))]
8233    pub schema: String,
8234    ///Property: Address
8235    #[serde(skip_serializing_if = "Option::is_none")]
8236    pub address: Option<Vec<String>>,
8237    ///Property: Address
8238    #[serde(skip_serializing_if = "Option::is_none")]
8239    pub address_entity: Option<Vec<String>>,
8240    ///Property: Aleph URL
8241    #[serde(skip_serializing_if = "Option::is_none")]
8242    pub aleph_url: Option<Vec<String>>,
8243    ///Property: Alias
8244    #[serde(skip_serializing_if = "Option::is_none")]
8245    pub alias: Option<Vec<String>>,
8246    ///Property: Ancestors
8247    #[serde(skip_serializing_if = "Option::is_none")]
8248    pub ancestors: Option<Vec<String>>,
8249    ///Property: Author
8250    #[serde(skip_serializing_if = "Option::is_none")]
8251    pub author: Option<Vec<String>>,
8252    ///Property: Authored on
8253    #[serde(skip_serializing_if = "Option::is_none")]
8254    pub authored_at: Option<Vec<String>>,
8255    ///Property: Text
8256    #[serde(skip_serializing_if = "Option::is_none")]
8257    pub body_text: Option<Vec<String>>,
8258    ///Property: Detected companies
8259    #[serde(skip_serializing_if = "Option::is_none")]
8260    pub companies_mentioned: Option<Vec<String>>,
8261    ///Property: Checksum
8262    #[serde(skip_serializing_if = "Option::is_none")]
8263    pub content_hash: Option<Vec<String>>,
8264    ///Property: Country
8265    #[serde(skip_serializing_if = "Option::is_none")]
8266    pub country: Option<Vec<String>>,
8267    ///Property: Crawler
8268    #[serde(skip_serializing_if = "Option::is_none")]
8269    pub crawler: Option<Vec<String>>,
8270    ///Property: Created at
8271    #[serde(skip_serializing_if = "Option::is_none")]
8272    pub created_at: Option<Vec<String>>,
8273    ///Property: Date
8274    #[serde(skip_serializing_if = "Option::is_none")]
8275    pub date: Option<Vec<String>>,
8276    ///Property: Description
8277    #[serde(skip_serializing_if = "Option::is_none")]
8278    pub description: Option<Vec<String>>,
8279    ///Property: Detected country
8280    #[serde(skip_serializing_if = "Option::is_none")]
8281    pub detected_country: Option<Vec<String>>,
8282    ///Property: Detected language
8283    #[serde(skip_serializing_if = "Option::is_none")]
8284    pub detected_language: Option<Vec<String>>,
8285    ///Property: Detected e-mail addresses
8286    #[serde(skip_serializing_if = "Option::is_none")]
8287    pub email_mentioned: Option<Vec<String>>,
8288    ///Property: File encoding
8289    #[serde(skip_serializing_if = "Option::is_none")]
8290    pub encoding: Option<Vec<String>>,
8291    ///Property: File extension
8292    #[serde(skip_serializing_if = "Option::is_none")]
8293    pub extension: Option<Vec<String>>,
8294    ///Property: File name
8295    #[serde(default)]
8296    pub file_name: Vec<String>,
8297    ///Property: File size
8298    #[serde(
8299        skip_serializing_if = "Option::is_none",
8300        deserialize_with = "deserialize_opt_f64_vec",
8301        default
8302    )]
8303    pub file_size: Option<Vec<f64>>,
8304    ///Property: Generator
8305    #[serde(skip_serializing_if = "Option::is_none")]
8306    pub generator: Option<Vec<String>>,
8307    ///Property: Detected IBANs
8308    #[serde(skip_serializing_if = "Option::is_none")]
8309    pub iban_mentioned: Option<Vec<String>>,
8310    ///Property: Index text
8311    #[serde(skip_serializing_if = "Option::is_none")]
8312    pub index_text: Option<Vec<String>>,
8313    ///Property: Detected IP addresses
8314    #[serde(skip_serializing_if = "Option::is_none")]
8315    pub ip_mentioned: Option<Vec<String>>,
8316    ///Property: Keywords
8317    #[serde(skip_serializing_if = "Option::is_none")]
8318    pub keywords: Option<Vec<String>>,
8319    ///Property: Language
8320    #[serde(skip_serializing_if = "Option::is_none")]
8321    pub language: Option<Vec<String>>,
8322    ///Property: Detected locations
8323    #[serde(skip_serializing_if = "Option::is_none")]
8324    pub location_mentioned: Option<Vec<String>>,
8325    ///Property: Message ID
8326    #[serde(skip_serializing_if = "Option::is_none")]
8327    pub message_id: Option<Vec<String>>,
8328    ///Property: MIME type
8329    #[serde(skip_serializing_if = "Option::is_none")]
8330    pub mime_type: Option<Vec<String>>,
8331    ///Property: Modified on
8332    #[serde(skip_serializing_if = "Option::is_none")]
8333    pub modified_at: Option<Vec<String>>,
8334    ///Property: Name
8335    #[serde(default)]
8336    pub name: Vec<String>,
8337    ///Property: Detected names
8338    #[serde(skip_serializing_if = "Option::is_none")]
8339    pub names_mentioned: Option<Vec<String>>,
8340    ///Property: Notes
8341    #[serde(skip_serializing_if = "Option::is_none")]
8342    pub notes: Option<Vec<String>>,
8343    ///Property: Folder
8344    #[serde(skip_serializing_if = "Option::is_none")]
8345    pub parent: Option<Vec<String>>,
8346    ///Property: Detected people
8347    #[serde(skip_serializing_if = "Option::is_none")]
8348    pub people_mentioned: Option<Vec<String>>,
8349    ///Property: Detected phones
8350    #[serde(skip_serializing_if = "Option::is_none")]
8351    pub phone_mentioned: Option<Vec<String>>,
8352    ///Property: Previous name
8353    #[serde(skip_serializing_if = "Option::is_none")]
8354    pub previous_name: Option<Vec<String>>,
8355    ///Property: Processed at
8356    #[serde(skip_serializing_if = "Option::is_none")]
8357    pub processed_at: Option<Vec<String>>,
8358    ///Property: Processing agent
8359    #[serde(skip_serializing_if = "Option::is_none")]
8360    pub processing_agent: Option<Vec<String>>,
8361    ///Property: Processing error
8362    #[serde(skip_serializing_if = "Option::is_none")]
8363    pub processing_error: Option<Vec<String>>,
8364    ///Property: Processing status
8365    #[serde(skip_serializing_if = "Option::is_none")]
8366    pub processing_status: Option<Vec<String>>,
8367    ///Property: Program
8368    #[serde(skip_serializing_if = "Option::is_none")]
8369    pub program: Option<Vec<String>>,
8370    ///Property: Program ID
8371    #[serde(skip_serializing_if = "Option::is_none")]
8372    pub program_id: Option<Vec<String>>,
8373    ///Property: Source document
8374    #[serde(skip_serializing_if = "Option::is_none")]
8375    pub proof: Option<Vec<String>>,
8376    ///Property: Published on
8377    #[serde(skip_serializing_if = "Option::is_none")]
8378    pub published_at: Option<Vec<String>>,
8379    ///Property: Publishing source
8380    #[serde(skip_serializing_if = "Option::is_none")]
8381    pub publisher: Option<Vec<String>>,
8382    ///Property: Publishing source URL
8383    #[serde(skip_serializing_if = "Option::is_none")]
8384    pub publisher_url: Option<Vec<String>>,
8385    ///Property: Retrieved on
8386    #[serde(skip_serializing_if = "Option::is_none")]
8387    pub retrieved_at: Option<Vec<String>>,
8388    ///Property: Source link
8389    #[serde(skip_serializing_if = "Option::is_none")]
8390    pub source_url: Option<Vec<String>>,
8391    ///Property: Summary
8392    #[serde(skip_serializing_if = "Option::is_none")]
8393    pub summary: Option<Vec<String>>,
8394    ///Property: Title
8395    #[serde(skip_serializing_if = "Option::is_none")]
8396    pub title: Option<Vec<String>>,
8397    ///Property: Topics
8398    #[serde(skip_serializing_if = "Option::is_none")]
8399    pub topics: Option<Vec<String>>,
8400    ///Property: The language of the translated text
8401    #[serde(skip_serializing_if = "Option::is_none")]
8402    pub translated_language: Option<Vec<String>>,
8403    ///Property: Translated version of the body text
8404    #[serde(skip_serializing_if = "Option::is_none")]
8405    pub translated_text: Option<Vec<String>>,
8406    ///Property: Weak alias
8407    #[serde(skip_serializing_if = "Option::is_none")]
8408    pub weak_alias: Option<Vec<String>>,
8409    ///Property: Wikidata ID
8410    #[serde(skip_serializing_if = "Option::is_none")]
8411    pub wikidata_id: Option<Vec<String>>,
8412    ///Property: Wikipedia Article
8413    #[serde(skip_serializing_if = "Option::is_none")]
8414    pub wikipedia_url: Option<Vec<String>>,
8415}
8416impl PlainText {
8417    /// Create a new entity with the given ID
8418    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
8419    pub fn new(id: impl Into<String>) -> Self {
8420        Self {
8421            id: id.into(),
8422            schema: "PlainText".to_string(),
8423            address: None,
8424            address_entity: None,
8425            aleph_url: None,
8426            alias: None,
8427            ancestors: None,
8428            author: None,
8429            authored_at: None,
8430            body_text: None,
8431            companies_mentioned: None,
8432            content_hash: None,
8433            country: None,
8434            crawler: None,
8435            created_at: None,
8436            date: None,
8437            description: None,
8438            detected_country: None,
8439            detected_language: None,
8440            email_mentioned: None,
8441            encoding: None,
8442            extension: None,
8443            file_name: Vec::new(),
8444            file_size: None,
8445            generator: None,
8446            iban_mentioned: None,
8447            index_text: None,
8448            ip_mentioned: None,
8449            keywords: None,
8450            language: None,
8451            location_mentioned: None,
8452            message_id: None,
8453            mime_type: None,
8454            modified_at: None,
8455            name: Vec::new(),
8456            names_mentioned: None,
8457            notes: None,
8458            parent: None,
8459            people_mentioned: None,
8460            phone_mentioned: None,
8461            previous_name: None,
8462            processed_at: None,
8463            processing_agent: None,
8464            processing_error: None,
8465            processing_status: None,
8466            program: None,
8467            program_id: None,
8468            proof: None,
8469            published_at: None,
8470            publisher: None,
8471            publisher_url: None,
8472            retrieved_at: None,
8473            source_url: None,
8474            summary: None,
8475            title: None,
8476            topics: None,
8477            translated_language: None,
8478            translated_text: None,
8479            weak_alias: None,
8480            wikidata_id: None,
8481            wikipedia_url: None,
8482        }
8483    }
8484    /// Get the schema name
8485    pub fn schema_name() -> &'static str {
8486        "PlainText"
8487    }
8488}
8489///FTM Schema: Position
8490#[derive(Debug, Clone, Serialize, Deserialize)]
8491#[cfg_attr(feature = "builder", derive(Builder))]
8492#[serde(rename_all = "camelCase")]
8493pub struct Position {
8494    pub id: String,
8495    #[cfg_attr(feature = "builder", builder(default = "Position".to_string()))]
8496    pub schema: String,
8497    ///Property: Address
8498    #[serde(skip_serializing_if = "Option::is_none")]
8499    pub address: Option<Vec<String>>,
8500    ///Property: Address
8501    #[serde(skip_serializing_if = "Option::is_none")]
8502    pub address_entity: Option<Vec<String>>,
8503    ///Property: Aleph URL
8504    #[serde(skip_serializing_if = "Option::is_none")]
8505    pub aleph_url: Option<Vec<String>>,
8506    ///Property: Alias
8507    #[serde(skip_serializing_if = "Option::is_none")]
8508    pub alias: Option<Vec<String>>,
8509    ///Property: Country
8510    #[serde(skip_serializing_if = "Option::is_none")]
8511    pub country: Option<Vec<String>>,
8512    ///Property: Created at
8513    #[serde(skip_serializing_if = "Option::is_none")]
8514    pub created_at: Option<Vec<String>>,
8515    ///Property: Description
8516    #[serde(skip_serializing_if = "Option::is_none")]
8517    pub description: Option<Vec<String>>,
8518    ///Property: Dissolution date
8519    #[serde(skip_serializing_if = "Option::is_none")]
8520    pub dissolution_date: Option<Vec<String>>,
8521    ///Property: Inception date
8522    #[serde(skip_serializing_if = "Option::is_none")]
8523    pub inception_date: Option<Vec<String>>,
8524    ///Property: Index text
8525    #[serde(skip_serializing_if = "Option::is_none")]
8526    pub index_text: Option<Vec<String>>,
8527    ///Property: Keywords
8528    #[serde(skip_serializing_if = "Option::is_none")]
8529    pub keywords: Option<Vec<String>>,
8530    ///Property: Modified on
8531    #[serde(skip_serializing_if = "Option::is_none")]
8532    pub modified_at: Option<Vec<String>>,
8533    ///Property: Name
8534    #[serde(default)]
8535    pub name: Vec<String>,
8536    ///Property: Notes
8537    #[serde(skip_serializing_if = "Option::is_none")]
8538    pub notes: Option<Vec<String>>,
8539    ///Property: Total number of seats
8540    #[serde(
8541        skip_serializing_if = "Option::is_none",
8542        deserialize_with = "deserialize_opt_f64_vec",
8543        default
8544    )]
8545    pub number_of_seats: Option<Vec<f64>>,
8546    ///Property: Organization
8547    #[serde(skip_serializing_if = "Option::is_none")]
8548    pub organization: Option<Vec<String>>,
8549    ///Property: Previous name
8550    #[serde(skip_serializing_if = "Option::is_none")]
8551    pub previous_name: Option<Vec<String>>,
8552    ///Property: Program
8553    #[serde(skip_serializing_if = "Option::is_none")]
8554    pub program: Option<Vec<String>>,
8555    ///Property: Program ID
8556    #[serde(skip_serializing_if = "Option::is_none")]
8557    pub program_id: Option<Vec<String>>,
8558    ///Property: Source document
8559    #[serde(skip_serializing_if = "Option::is_none")]
8560    pub proof: Option<Vec<String>>,
8561    ///Property: Publishing source
8562    #[serde(skip_serializing_if = "Option::is_none")]
8563    pub publisher: Option<Vec<String>>,
8564    ///Property: Publishing source URL
8565    #[serde(skip_serializing_if = "Option::is_none")]
8566    pub publisher_url: Option<Vec<String>>,
8567    ///Property: Retrieved on
8568    #[serde(skip_serializing_if = "Option::is_none")]
8569    pub retrieved_at: Option<Vec<String>>,
8570    ///Property: Source link
8571    #[serde(skip_serializing_if = "Option::is_none")]
8572    pub source_url: Option<Vec<String>>,
8573    ///Property: Subnational jurisdiction name or code
8574    #[serde(skip_serializing_if = "Option::is_none")]
8575    pub subnational_area: Option<Vec<String>>,
8576    ///Property: Summary
8577    #[serde(skip_serializing_if = "Option::is_none")]
8578    pub summary: Option<Vec<String>>,
8579    ///Property: Topics
8580    #[serde(skip_serializing_if = "Option::is_none")]
8581    pub topics: Option<Vec<String>>,
8582    ///Property: Weak alias
8583    #[serde(skip_serializing_if = "Option::is_none")]
8584    pub weak_alias: Option<Vec<String>>,
8585    ///Property: Wikidata ID
8586    #[serde(skip_serializing_if = "Option::is_none")]
8587    pub wikidata_id: Option<Vec<String>>,
8588    ///Property: Wikipedia Article
8589    #[serde(skip_serializing_if = "Option::is_none")]
8590    pub wikipedia_url: Option<Vec<String>>,
8591}
8592impl Position {
8593    /// Create a new entity with the given ID
8594    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
8595    pub fn new(id: impl Into<String>) -> Self {
8596        Self {
8597            id: id.into(),
8598            schema: "Position".to_string(),
8599            address: None,
8600            address_entity: None,
8601            aleph_url: None,
8602            alias: None,
8603            country: None,
8604            created_at: None,
8605            description: None,
8606            dissolution_date: None,
8607            inception_date: None,
8608            index_text: None,
8609            keywords: None,
8610            modified_at: None,
8611            name: Vec::new(),
8612            notes: None,
8613            number_of_seats: None,
8614            organization: None,
8615            previous_name: None,
8616            program: None,
8617            program_id: None,
8618            proof: None,
8619            publisher: None,
8620            publisher_url: None,
8621            retrieved_at: None,
8622            source_url: None,
8623            subnational_area: None,
8624            summary: None,
8625            topics: None,
8626            weak_alias: None,
8627            wikidata_id: None,
8628            wikipedia_url: None,
8629        }
8630    }
8631    /// Get the schema name
8632    pub fn schema_name() -> &'static str {
8633        "Position"
8634    }
8635}
8636///FTM Schema: Project
8637#[derive(Debug, Clone, Serialize, Deserialize)]
8638#[cfg_attr(feature = "builder", derive(Builder))]
8639#[serde(rename_all = "camelCase")]
8640pub struct Project {
8641    pub id: String,
8642    #[cfg_attr(feature = "builder", builder(default = "Project".to_string()))]
8643    pub schema: String,
8644    ///Property: Address
8645    #[serde(skip_serializing_if = "Option::is_none")]
8646    pub address: Option<Vec<String>>,
8647    ///Property: Address
8648    #[serde(skip_serializing_if = "Option::is_none")]
8649    pub address_entity: Option<Vec<String>>,
8650    ///Property: Aleph URL
8651    #[serde(skip_serializing_if = "Option::is_none")]
8652    pub aleph_url: Option<Vec<String>>,
8653    ///Property: Alias
8654    #[serde(skip_serializing_if = "Option::is_none")]
8655    pub alias: Option<Vec<String>>,
8656    ///Property: Amount
8657    #[serde(
8658        skip_serializing_if = "Option::is_none",
8659        deserialize_with = "deserialize_opt_f64_vec",
8660        default
8661    )]
8662    pub amount: Option<Vec<f64>>,
8663    ///Property: Amount in EUR
8664    #[serde(
8665        skip_serializing_if = "Option::is_none",
8666        deserialize_with = "deserialize_opt_f64_vec",
8667        default
8668    )]
8669    pub amount_eur: Option<Vec<f64>>,
8670    ///Property: Amount in USD
8671    #[serde(
8672        skip_serializing_if = "Option::is_none",
8673        deserialize_with = "deserialize_opt_f64_vec",
8674        default
8675    )]
8676    pub amount_usd: Option<Vec<f64>>,
8677    ///Property: Country
8678    #[serde(skip_serializing_if = "Option::is_none")]
8679    pub country: Option<Vec<String>>,
8680    ///Property: Created at
8681    #[serde(skip_serializing_if = "Option::is_none")]
8682    pub created_at: Option<Vec<String>>,
8683    ///Property: Currency
8684    #[serde(skip_serializing_if = "Option::is_none")]
8685    pub currency: Option<Vec<String>>,
8686    ///Property: Date
8687    #[serde(skip_serializing_if = "Option::is_none")]
8688    pub date: Option<Vec<String>>,
8689    ///Property: Description
8690    #[serde(skip_serializing_if = "Option::is_none")]
8691    pub description: Option<Vec<String>>,
8692    ///Property: End date
8693    #[serde(skip_serializing_if = "Option::is_none")]
8694    pub end_date: Option<Vec<String>>,
8695    ///Property: Project goal
8696    #[serde(skip_serializing_if = "Option::is_none")]
8697    pub goal: Option<Vec<String>>,
8698    ///Property: Index text
8699    #[serde(skip_serializing_if = "Option::is_none")]
8700    pub index_text: Option<Vec<String>>,
8701    ///Property: Keywords
8702    #[serde(skip_serializing_if = "Option::is_none")]
8703    pub keywords: Option<Vec<String>>,
8704    ///Property: Modified on
8705    #[serde(skip_serializing_if = "Option::is_none")]
8706    pub modified_at: Option<Vec<String>>,
8707    ///Property: Name
8708    #[serde(default)]
8709    pub name: Vec<String>,
8710    ///Property: Detected names
8711    #[serde(skip_serializing_if = "Option::is_none")]
8712    pub names_mentioned: Option<Vec<String>>,
8713    ///Property: Notes
8714    #[serde(skip_serializing_if = "Option::is_none")]
8715    pub notes: Option<Vec<String>>,
8716    ///Property: Phase
8717    #[serde(skip_serializing_if = "Option::is_none")]
8718    pub phase: Option<Vec<String>>,
8719    ///Property: Previous name
8720    #[serde(skip_serializing_if = "Option::is_none")]
8721    pub previous_name: Option<Vec<String>>,
8722    ///Property: Program
8723    #[serde(skip_serializing_if = "Option::is_none")]
8724    pub program: Option<Vec<String>>,
8725    ///Property: Program ID
8726    #[serde(skip_serializing_if = "Option::is_none")]
8727    pub program_id: Option<Vec<String>>,
8728    ///Property: Project ID
8729    #[serde(skip_serializing_if = "Option::is_none")]
8730    pub project_id: Option<Vec<String>>,
8731    ///Property: Source document
8732    #[serde(skip_serializing_if = "Option::is_none")]
8733    pub proof: Option<Vec<String>>,
8734    ///Property: Publishing source
8735    #[serde(skip_serializing_if = "Option::is_none")]
8736    pub publisher: Option<Vec<String>>,
8737    ///Property: Publishing source URL
8738    #[serde(skip_serializing_if = "Option::is_none")]
8739    pub publisher_url: Option<Vec<String>>,
8740    ///Property: Record ID
8741    #[serde(skip_serializing_if = "Option::is_none")]
8742    pub record_id: Option<Vec<String>>,
8743    ///Property: Retrieved on
8744    #[serde(skip_serializing_if = "Option::is_none")]
8745    pub retrieved_at: Option<Vec<String>>,
8746    ///Property: Source link
8747    #[serde(skip_serializing_if = "Option::is_none")]
8748    pub source_url: Option<Vec<String>>,
8749    ///Property: Start date
8750    #[serde(skip_serializing_if = "Option::is_none")]
8751    pub start_date: Option<Vec<String>>,
8752    ///Property: Status
8753    #[serde(skip_serializing_if = "Option::is_none")]
8754    pub status: Option<Vec<String>>,
8755    ///Property: Summary
8756    #[serde(skip_serializing_if = "Option::is_none")]
8757    pub summary: Option<Vec<String>>,
8758    ///Property: Topics
8759    #[serde(skip_serializing_if = "Option::is_none")]
8760    pub topics: Option<Vec<String>>,
8761    ///Property: Weak alias
8762    #[serde(skip_serializing_if = "Option::is_none")]
8763    pub weak_alias: Option<Vec<String>>,
8764    ///Property: Wikidata ID
8765    #[serde(skip_serializing_if = "Option::is_none")]
8766    pub wikidata_id: Option<Vec<String>>,
8767    ///Property: Wikipedia Article
8768    #[serde(skip_serializing_if = "Option::is_none")]
8769    pub wikipedia_url: Option<Vec<String>>,
8770}
8771impl Project {
8772    /// Create a new entity with the given ID
8773    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
8774    pub fn new(id: impl Into<String>) -> Self {
8775        Self {
8776            id: id.into(),
8777            schema: "Project".to_string(),
8778            address: None,
8779            address_entity: None,
8780            aleph_url: None,
8781            alias: None,
8782            amount: None,
8783            amount_eur: None,
8784            amount_usd: None,
8785            country: None,
8786            created_at: None,
8787            currency: None,
8788            date: None,
8789            description: None,
8790            end_date: None,
8791            goal: None,
8792            index_text: None,
8793            keywords: None,
8794            modified_at: None,
8795            name: Vec::new(),
8796            names_mentioned: None,
8797            notes: None,
8798            phase: None,
8799            previous_name: None,
8800            program: None,
8801            program_id: None,
8802            project_id: None,
8803            proof: None,
8804            publisher: None,
8805            publisher_url: None,
8806            record_id: None,
8807            retrieved_at: None,
8808            source_url: None,
8809            start_date: None,
8810            status: None,
8811            summary: None,
8812            topics: None,
8813            weak_alias: None,
8814            wikidata_id: None,
8815            wikipedia_url: None,
8816        }
8817    }
8818    /// Get the schema name
8819    pub fn schema_name() -> &'static str {
8820        "Project"
8821    }
8822}
8823///FTM Schema: Project participant
8824#[derive(Debug, Clone, Serialize, Deserialize)]
8825#[cfg_attr(feature = "builder", derive(Builder))]
8826#[serde(rename_all = "camelCase")]
8827pub struct ProjectParticipant {
8828    pub id: String,
8829    #[cfg_attr(feature = "builder", builder(default = "ProjectParticipant".to_string()))]
8830    pub schema: String,
8831    ///Property: Aleph URL
8832    #[serde(skip_serializing_if = "Option::is_none")]
8833    pub aleph_url: Option<Vec<String>>,
8834    ///Property: Date
8835    #[serde(skip_serializing_if = "Option::is_none")]
8836    pub date: Option<Vec<String>>,
8837    ///Property: Description
8838    #[serde(skip_serializing_if = "Option::is_none")]
8839    pub description: Option<Vec<String>>,
8840    ///Property: End date
8841    #[serde(skip_serializing_if = "Option::is_none")]
8842    pub end_date: Option<Vec<String>>,
8843    ///Property: Index text
8844    #[serde(skip_serializing_if = "Option::is_none")]
8845    pub index_text: Option<Vec<String>>,
8846    ///Property: Modified on
8847    #[serde(skip_serializing_if = "Option::is_none")]
8848    pub modified_at: Option<Vec<String>>,
8849    ///Property: Detected names
8850    #[serde(skip_serializing_if = "Option::is_none")]
8851    pub names_mentioned: Option<Vec<String>>,
8852    ///Property: Participant
8853    #[serde(skip_serializing_if = "Option::is_none")]
8854    pub participant: Option<Vec<String>>,
8855    ///Property: Project
8856    #[serde(skip_serializing_if = "Option::is_none")]
8857    pub project: Option<Vec<String>>,
8858    ///Property: Source document
8859    #[serde(skip_serializing_if = "Option::is_none")]
8860    pub proof: Option<Vec<String>>,
8861    ///Property: Publishing source
8862    #[serde(skip_serializing_if = "Option::is_none")]
8863    pub publisher: Option<Vec<String>>,
8864    ///Property: Publishing source URL
8865    #[serde(skip_serializing_if = "Option::is_none")]
8866    pub publisher_url: Option<Vec<String>>,
8867    ///Property: Record ID
8868    #[serde(skip_serializing_if = "Option::is_none")]
8869    pub record_id: Option<Vec<String>>,
8870    ///Property: Retrieved on
8871    #[serde(skip_serializing_if = "Option::is_none")]
8872    pub retrieved_at: Option<Vec<String>>,
8873    ///Property: Role
8874    #[serde(skip_serializing_if = "Option::is_none")]
8875    pub role: Option<Vec<String>>,
8876    ///Property: Source link
8877    #[serde(skip_serializing_if = "Option::is_none")]
8878    pub source_url: Option<Vec<String>>,
8879    ///Property: Start date
8880    #[serde(skip_serializing_if = "Option::is_none")]
8881    pub start_date: Option<Vec<String>>,
8882    ///Property: Status
8883    #[serde(skip_serializing_if = "Option::is_none")]
8884    pub status: Option<Vec<String>>,
8885    ///Property: Summary
8886    #[serde(skip_serializing_if = "Option::is_none")]
8887    pub summary: Option<Vec<String>>,
8888}
8889impl ProjectParticipant {
8890    /// Create a new entity with the given ID
8891    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
8892    pub fn new(id: impl Into<String>) -> Self {
8893        Self {
8894            id: id.into(),
8895            schema: "ProjectParticipant".to_string(),
8896            aleph_url: None,
8897            date: None,
8898            description: None,
8899            end_date: None,
8900            index_text: None,
8901            modified_at: None,
8902            names_mentioned: None,
8903            participant: None,
8904            project: None,
8905            proof: None,
8906            publisher: None,
8907            publisher_url: None,
8908            record_id: None,
8909            retrieved_at: None,
8910            role: None,
8911            source_url: None,
8912            start_date: None,
8913            status: None,
8914            summary: None,
8915        }
8916    }
8917    /// Get the schema name
8918    pub fn schema_name() -> &'static str {
8919        "ProjectParticipant"
8920    }
8921}
8922///FTM Schema: Public body
8923#[derive(Debug, Clone, Serialize, Deserialize)]
8924#[cfg_attr(feature = "builder", derive(Builder))]
8925#[serde(rename_all = "camelCase")]
8926pub struct PublicBody {
8927    pub id: String,
8928    #[cfg_attr(feature = "builder", builder(default = "PublicBody".to_string()))]
8929    pub schema: String,
8930    ///Property: Abbreviation
8931    #[serde(skip_serializing_if = "Option::is_none")]
8932    pub abbreviation: Option<Vec<String>>,
8933    ///Property: Address
8934    #[serde(skip_serializing_if = "Option::is_none")]
8935    pub address: Option<Vec<String>>,
8936    ///Property: Address
8937    #[serde(skip_serializing_if = "Option::is_none")]
8938    pub address_entity: Option<Vec<String>>,
8939    ///Property: Aleph URL
8940    #[serde(skip_serializing_if = "Option::is_none")]
8941    pub aleph_url: Option<Vec<String>>,
8942    ///Property: Alias
8943    #[serde(skip_serializing_if = "Option::is_none")]
8944    pub alias: Option<Vec<String>>,
8945    ///Property: BrightQuery ID
8946    #[serde(skip_serializing_if = "Option::is_none")]
8947    pub bright_query_id: Option<Vec<String>>,
8948    ///Property: BrightQuery Organization ID
8949    #[serde(skip_serializing_if = "Option::is_none")]
8950    pub bright_query_org_id: Option<Vec<String>>,
8951    ///Property: Bureau van Dijk ID
8952    #[serde(skip_serializing_if = "Option::is_none")]
8953    pub bvd_id: Option<Vec<String>>,
8954    ///Property: CAGE
8955    #[serde(skip_serializing_if = "Option::is_none")]
8956    pub cage_code: Option<Vec<String>>,
8957    ///Property: Classification
8958    #[serde(skip_serializing_if = "Option::is_none")]
8959    pub classification: Option<Vec<String>>,
8960    ///Property: Country
8961    #[serde(skip_serializing_if = "Option::is_none")]
8962    pub country: Option<Vec<String>>,
8963    ///Property: Created at
8964    #[serde(skip_serializing_if = "Option::is_none")]
8965    pub created_at: Option<Vec<String>>,
8966    ///Property: Description
8967    #[serde(skip_serializing_if = "Option::is_none")]
8968    pub description: Option<Vec<String>>,
8969    ///Property: Dissolution date
8970    #[serde(skip_serializing_if = "Option::is_none")]
8971    pub dissolution_date: Option<Vec<String>>,
8972    ///Property: DUNS
8973    #[serde(skip_serializing_if = "Option::is_none")]
8974    pub duns_code: Option<Vec<String>>,
8975    ///Property: E-Mail
8976    #[serde(skip_serializing_if = "Option::is_none")]
8977    pub email: Option<Vec<String>>,
8978    ///Property: GIIN
8979    #[serde(skip_serializing_if = "Option::is_none")]
8980    pub gii_number: Option<Vec<String>>,
8981    ///Property: ICIJ ID
8982    #[serde(skip_serializing_if = "Option::is_none")]
8983    pub icij_id: Option<Vec<String>>,
8984    ///Property: ID Number
8985    #[serde(skip_serializing_if = "Option::is_none")]
8986    pub id_number: Option<Vec<String>>,
8987    ///Property: IMO Number
8988    #[serde(skip_serializing_if = "Option::is_none")]
8989    pub imo_number: Option<Vec<String>>,
8990    ///Property: Incorporation date
8991    #[serde(skip_serializing_if = "Option::is_none")]
8992    pub incorporation_date: Option<Vec<String>>,
8993    ///Property: Index text
8994    #[serde(skip_serializing_if = "Option::is_none")]
8995    pub index_text: Option<Vec<String>>,
8996    ///Property: INN
8997    #[serde(skip_serializing_if = "Option::is_none")]
8998    pub inn_code: Option<Vec<String>>,
8999    ///Property: Jurisdiction
9000    #[serde(skip_serializing_if = "Option::is_none")]
9001    pub jurisdiction: Option<Vec<String>>,
9002    ///Property: Keywords
9003    #[serde(skip_serializing_if = "Option::is_none")]
9004    pub keywords: Option<Vec<String>>,
9005    ///Property: Legal form
9006    #[serde(skip_serializing_if = "Option::is_none")]
9007    pub legal_form: Option<Vec<String>>,
9008    ///Property: LEI
9009    #[serde(skip_serializing_if = "Option::is_none")]
9010    pub lei_code: Option<Vec<String>>,
9011    ///Property: License Number
9012    #[serde(skip_serializing_if = "Option::is_none")]
9013    pub license_number: Option<Vec<String>>,
9014    ///Property: Country of origin
9015    #[serde(skip_serializing_if = "Option::is_none")]
9016    pub main_country: Option<Vec<String>>,
9017    ///Property: Modified on
9018    #[serde(skip_serializing_if = "Option::is_none")]
9019    pub modified_at: Option<Vec<String>>,
9020    ///Property: Name
9021    #[serde(default)]
9022    pub name: Vec<String>,
9023    ///Property: Notes
9024    #[serde(skip_serializing_if = "Option::is_none")]
9025    pub notes: Option<Vec<String>>,
9026    ///Property: NPI
9027    #[serde(skip_serializing_if = "Option::is_none")]
9028    pub npi_code: Option<Vec<String>>,
9029    ///Property: OGRN
9030    #[serde(skip_serializing_if = "Option::is_none")]
9031    pub ogrn_code: Option<Vec<String>>,
9032    ///Property: OKPO
9033    #[serde(skip_serializing_if = "Option::is_none")]
9034    pub okpo_code: Option<Vec<String>>,
9035    ///Property: OpenCorporates URL
9036    #[serde(skip_serializing_if = "Option::is_none")]
9037    pub opencorporates_url: Option<Vec<String>>,
9038    ///Property: Parent company
9039    #[serde(skip_serializing_if = "Option::is_none")]
9040    pub parent: Option<Vec<String>>,
9041    ///Property: PermID
9042    #[serde(skip_serializing_if = "Option::is_none")]
9043    pub perm_id: Option<Vec<String>>,
9044    ///Property: Phone
9045    #[serde(skip_serializing_if = "Option::is_none")]
9046    pub phone: Option<Vec<String>>,
9047    ///Property: Previous name
9048    #[serde(skip_serializing_if = "Option::is_none")]
9049    pub previous_name: Option<Vec<String>>,
9050    ///Property: Program
9051    #[serde(skip_serializing_if = "Option::is_none")]
9052    pub program: Option<Vec<String>>,
9053    ///Property: Program ID
9054    #[serde(skip_serializing_if = "Option::is_none")]
9055    pub program_id: Option<Vec<String>>,
9056    ///Property: Source document
9057    #[serde(skip_serializing_if = "Option::is_none")]
9058    pub proof: Option<Vec<String>>,
9059    ///Property: Publishing source
9060    #[serde(skip_serializing_if = "Option::is_none")]
9061    pub publisher: Option<Vec<String>>,
9062    ///Property: Publishing source URL
9063    #[serde(skip_serializing_if = "Option::is_none")]
9064    pub publisher_url: Option<Vec<String>>,
9065    ///Property: Registration number
9066    #[serde(skip_serializing_if = "Option::is_none")]
9067    pub registration_number: Option<Vec<String>>,
9068    ///Property: Retrieved on
9069    #[serde(skip_serializing_if = "Option::is_none")]
9070    pub retrieved_at: Option<Vec<String>>,
9071    ///Property: Sayari Entity ID
9072    #[serde(skip_serializing_if = "Option::is_none")]
9073    pub sayari_id: Option<Vec<String>>,
9074    ///Property: Sector
9075    #[serde(skip_serializing_if = "Option::is_none")]
9076    pub sector: Option<Vec<String>>,
9077    ///Property: Source link
9078    #[serde(skip_serializing_if = "Option::is_none")]
9079    pub source_url: Option<Vec<String>>,
9080    ///Property: Status
9081    #[serde(skip_serializing_if = "Option::is_none")]
9082    pub status: Option<Vec<String>>,
9083    ///Property: Summary
9084    #[serde(skip_serializing_if = "Option::is_none")]
9085    pub summary: Option<Vec<String>>,
9086    ///Property: SWIFT/BIC
9087    #[serde(skip_serializing_if = "Option::is_none")]
9088    pub swift_bic: Option<Vec<String>>,
9089    ///Property: Tax Number
9090    #[serde(skip_serializing_if = "Option::is_none")]
9091    pub tax_number: Option<Vec<String>>,
9092    ///Property: Tax status
9093    #[serde(skip_serializing_if = "Option::is_none")]
9094    pub tax_status: Option<Vec<String>>,
9095    ///Property: Topics
9096    #[serde(skip_serializing_if = "Option::is_none")]
9097    pub topics: Option<Vec<String>>,
9098    ///Property: Unique Entity ID
9099    #[serde(skip_serializing_if = "Option::is_none")]
9100    pub unique_entity_id: Option<Vec<String>>,
9101    ///Property: USCC
9102    #[serde(skip_serializing_if = "Option::is_none")]
9103    pub usc_code: Option<Vec<String>>,
9104    ///Property: V.A.T. Identifier
9105    #[serde(skip_serializing_if = "Option::is_none")]
9106    pub vat_code: Option<Vec<String>>,
9107    ///Property: Weak alias
9108    #[serde(skip_serializing_if = "Option::is_none")]
9109    pub weak_alias: Option<Vec<String>>,
9110    ///Property: Website
9111    #[serde(skip_serializing_if = "Option::is_none")]
9112    pub website: Option<Vec<String>>,
9113    ///Property: Wikidata ID
9114    #[serde(skip_serializing_if = "Option::is_none")]
9115    pub wikidata_id: Option<Vec<String>>,
9116    ///Property: Wikipedia Article
9117    #[serde(skip_serializing_if = "Option::is_none")]
9118    pub wikipedia_url: Option<Vec<String>>,
9119}
9120impl PublicBody {
9121    /// Create a new entity with the given ID
9122    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
9123    pub fn new(id: impl Into<String>) -> Self {
9124        Self {
9125            id: id.into(),
9126            schema: "PublicBody".to_string(),
9127            abbreviation: None,
9128            address: None,
9129            address_entity: None,
9130            aleph_url: None,
9131            alias: None,
9132            bright_query_id: None,
9133            bright_query_org_id: None,
9134            bvd_id: None,
9135            cage_code: None,
9136            classification: None,
9137            country: None,
9138            created_at: None,
9139            description: None,
9140            dissolution_date: None,
9141            duns_code: None,
9142            email: None,
9143            gii_number: None,
9144            icij_id: None,
9145            id_number: None,
9146            imo_number: None,
9147            incorporation_date: None,
9148            index_text: None,
9149            inn_code: None,
9150            jurisdiction: None,
9151            keywords: None,
9152            legal_form: None,
9153            lei_code: None,
9154            license_number: None,
9155            main_country: None,
9156            modified_at: None,
9157            name: Vec::new(),
9158            notes: None,
9159            npi_code: None,
9160            ogrn_code: None,
9161            okpo_code: None,
9162            opencorporates_url: None,
9163            parent: None,
9164            perm_id: None,
9165            phone: None,
9166            previous_name: None,
9167            program: None,
9168            program_id: None,
9169            proof: None,
9170            publisher: None,
9171            publisher_url: None,
9172            registration_number: None,
9173            retrieved_at: None,
9174            sayari_id: None,
9175            sector: None,
9176            source_url: None,
9177            status: None,
9178            summary: None,
9179            swift_bic: None,
9180            tax_number: None,
9181            tax_status: None,
9182            topics: None,
9183            unique_entity_id: None,
9184            usc_code: None,
9185            vat_code: None,
9186            weak_alias: None,
9187            website: None,
9188            wikidata_id: None,
9189            wikipedia_url: None,
9190        }
9191    }
9192    /// Get the schema name
9193    pub fn schema_name() -> &'static str {
9194        "PublicBody"
9195    }
9196}
9197///FTM Schema: Real estate
9198#[derive(Debug, Clone, Serialize, Deserialize)]
9199#[cfg_attr(feature = "builder", derive(Builder))]
9200#[serde(rename_all = "camelCase")]
9201pub struct RealEstate {
9202    pub id: String,
9203    #[cfg_attr(feature = "builder", builder(default = "RealEstate".to_string()))]
9204    pub schema: String,
9205    ///Property: Address
9206    #[serde(skip_serializing_if = "Option::is_none")]
9207    pub address: Option<Vec<String>>,
9208    ///Property: Address
9209    #[serde(skip_serializing_if = "Option::is_none")]
9210    pub address_entity: Option<Vec<String>>,
9211    ///Property: Aleph URL
9212    #[serde(skip_serializing_if = "Option::is_none")]
9213    pub aleph_url: Option<Vec<String>>,
9214    ///Property: Alias
9215    #[serde(skip_serializing_if = "Option::is_none")]
9216    pub alias: Option<Vec<String>>,
9217    ///Property: Amount
9218    #[serde(
9219        skip_serializing_if = "Option::is_none",
9220        deserialize_with = "deserialize_opt_f64_vec",
9221        default
9222    )]
9223    pub amount: Option<Vec<f64>>,
9224    ///Property: Amount in EUR
9225    #[serde(
9226        skip_serializing_if = "Option::is_none",
9227        deserialize_with = "deserialize_opt_f64_vec",
9228        default
9229    )]
9230    pub amount_eur: Option<Vec<f64>>,
9231    ///Property: Amount in USD
9232    #[serde(
9233        skip_serializing_if = "Option::is_none",
9234        deserialize_with = "deserialize_opt_f64_vec",
9235        default
9236    )]
9237    pub amount_usd: Option<Vec<f64>>,
9238    ///Property: Area
9239    #[serde(
9240        skip_serializing_if = "Option::is_none",
9241        deserialize_with = "deserialize_opt_f64_vec",
9242        default
9243    )]
9244    pub area: Option<Vec<f64>>,
9245    ///Property: Cadastral code
9246    #[serde(skip_serializing_if = "Option::is_none")]
9247    pub cadastral_code: Option<Vec<String>>,
9248    ///Property: Census block
9249    #[serde(skip_serializing_if = "Option::is_none")]
9250    pub census_block: Option<Vec<String>>,
9251    ///Property: Country
9252    #[serde(skip_serializing_if = "Option::is_none")]
9253    pub country: Option<Vec<String>>,
9254    ///Property: Record date
9255    #[serde(skip_serializing_if = "Option::is_none")]
9256    pub create_date: Option<Vec<String>>,
9257    ///Property: Created at
9258    #[serde(skip_serializing_if = "Option::is_none")]
9259    pub created_at: Option<Vec<String>>,
9260    ///Property: Currency
9261    #[serde(skip_serializing_if = "Option::is_none")]
9262    pub currency: Option<Vec<String>>,
9263    ///Property: Description
9264    #[serde(skip_serializing_if = "Option::is_none")]
9265    pub description: Option<Vec<String>>,
9266    ///Property: Encumbrance
9267    #[serde(skip_serializing_if = "Option::is_none")]
9268    pub encumbrance: Option<Vec<String>>,
9269    ///Property: Index text
9270    #[serde(skip_serializing_if = "Option::is_none")]
9271    pub index_text: Option<Vec<String>>,
9272    ///Property: Keywords
9273    #[serde(skip_serializing_if = "Option::is_none")]
9274    pub keywords: Option<Vec<String>>,
9275    ///Property: Land type
9276    #[serde(skip_serializing_if = "Option::is_none")]
9277    pub land_type: Option<Vec<String>>,
9278    ///Property: Latitude
9279    #[serde(
9280        skip_serializing_if = "Option::is_none",
9281        deserialize_with = "deserialize_opt_f64_vec",
9282        default
9283    )]
9284    pub latitude: Option<Vec<f64>>,
9285    ///Property: Longitude
9286    #[serde(
9287        skip_serializing_if = "Option::is_none",
9288        deserialize_with = "deserialize_opt_f64_vec",
9289        default
9290    )]
9291    pub longitude: Option<Vec<f64>>,
9292    ///Property: Modified on
9293    #[serde(skip_serializing_if = "Option::is_none")]
9294    pub modified_at: Option<Vec<String>>,
9295    ///Property: Name
9296    #[serde(default)]
9297    pub name: Vec<String>,
9298    ///Property: Notes
9299    #[serde(skip_serializing_if = "Option::is_none")]
9300    pub notes: Option<Vec<String>>,
9301    ///Property: Parent unit
9302    #[serde(skip_serializing_if = "Option::is_none")]
9303    pub parent: Option<Vec<String>>,
9304    ///Property: Previous name
9305    #[serde(skip_serializing_if = "Option::is_none")]
9306    pub previous_name: Option<Vec<String>>,
9307    ///Property: Program
9308    #[serde(skip_serializing_if = "Option::is_none")]
9309    pub program: Option<Vec<String>>,
9310    ///Property: Program ID
9311    #[serde(skip_serializing_if = "Option::is_none")]
9312    pub program_id: Option<Vec<String>>,
9313    ///Property: Source document
9314    #[serde(skip_serializing_if = "Option::is_none")]
9315    pub proof: Option<Vec<String>>,
9316    ///Property: Property type
9317    #[serde(skip_serializing_if = "Option::is_none")]
9318    pub property_type: Option<Vec<String>>,
9319    ///Property: Publishing source
9320    #[serde(skip_serializing_if = "Option::is_none")]
9321    pub publisher: Option<Vec<String>>,
9322    ///Property: Publishing source URL
9323    #[serde(skip_serializing_if = "Option::is_none")]
9324    pub publisher_url: Option<Vec<String>>,
9325    ///Property: Registration number
9326    #[serde(skip_serializing_if = "Option::is_none")]
9327    pub registration_number: Option<Vec<String>>,
9328    ///Property: Retrieved on
9329    #[serde(skip_serializing_if = "Option::is_none")]
9330    pub retrieved_at: Option<Vec<String>>,
9331    ///Property: Source link
9332    #[serde(skip_serializing_if = "Option::is_none")]
9333    pub source_url: Option<Vec<String>>,
9334    ///Property: Summary
9335    #[serde(skip_serializing_if = "Option::is_none")]
9336    pub summary: Option<Vec<String>>,
9337    ///Property: Tenure
9338    #[serde(skip_serializing_if = "Option::is_none")]
9339    pub tenure: Option<Vec<String>>,
9340    ///Property: Title number
9341    #[serde(skip_serializing_if = "Option::is_none")]
9342    pub title_number: Option<Vec<String>>,
9343    ///Property: Topics
9344    #[serde(skip_serializing_if = "Option::is_none")]
9345    pub topics: Option<Vec<String>>,
9346    ///Property: Weak alias
9347    #[serde(skip_serializing_if = "Option::is_none")]
9348    pub weak_alias: Option<Vec<String>>,
9349    ///Property: Wikidata ID
9350    #[serde(skip_serializing_if = "Option::is_none")]
9351    pub wikidata_id: Option<Vec<String>>,
9352    ///Property: Wikipedia Article
9353    #[serde(skip_serializing_if = "Option::is_none")]
9354    pub wikipedia_url: Option<Vec<String>>,
9355}
9356impl RealEstate {
9357    /// Create a new entity with the given ID
9358    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
9359    pub fn new(id: impl Into<String>) -> Self {
9360        Self {
9361            id: id.into(),
9362            schema: "RealEstate".to_string(),
9363            address: None,
9364            address_entity: None,
9365            aleph_url: None,
9366            alias: None,
9367            amount: None,
9368            amount_eur: None,
9369            amount_usd: None,
9370            area: None,
9371            cadastral_code: None,
9372            census_block: None,
9373            country: None,
9374            create_date: None,
9375            created_at: None,
9376            currency: None,
9377            description: None,
9378            encumbrance: None,
9379            index_text: None,
9380            keywords: None,
9381            land_type: None,
9382            latitude: None,
9383            longitude: None,
9384            modified_at: None,
9385            name: Vec::new(),
9386            notes: None,
9387            parent: None,
9388            previous_name: None,
9389            program: None,
9390            program_id: None,
9391            proof: None,
9392            property_type: None,
9393            publisher: None,
9394            publisher_url: None,
9395            registration_number: None,
9396            retrieved_at: None,
9397            source_url: None,
9398            summary: None,
9399            tenure: None,
9400            title_number: None,
9401            topics: None,
9402            weak_alias: None,
9403            wikidata_id: None,
9404            wikipedia_url: None,
9405        }
9406    }
9407    /// Get the schema name
9408    pub fn schema_name() -> &'static str {
9409        "RealEstate"
9410    }
9411}
9412///FTM Schema: Representation
9413#[derive(Debug, Clone, Serialize, Deserialize)]
9414#[cfg_attr(feature = "builder", derive(Builder))]
9415#[serde(rename_all = "camelCase")]
9416pub struct Representation {
9417    pub id: String,
9418    #[cfg_attr(feature = "builder", builder(default = "Representation".to_string()))]
9419    pub schema: String,
9420    ///Property: Agent
9421    #[serde(default)]
9422    pub agent: Vec<String>,
9423    ///Property: Aleph URL
9424    #[serde(skip_serializing_if = "Option::is_none")]
9425    pub aleph_url: Option<Vec<String>>,
9426    ///Property: Client
9427    #[serde(default)]
9428    pub client: Vec<String>,
9429    ///Property: Date
9430    #[serde(skip_serializing_if = "Option::is_none")]
9431    pub date: Option<Vec<String>>,
9432    ///Property: Description
9433    #[serde(skip_serializing_if = "Option::is_none")]
9434    pub description: Option<Vec<String>>,
9435    ///Property: End date
9436    #[serde(skip_serializing_if = "Option::is_none")]
9437    pub end_date: Option<Vec<String>>,
9438    ///Property: Index text
9439    #[serde(skip_serializing_if = "Option::is_none")]
9440    pub index_text: Option<Vec<String>>,
9441    ///Property: Modified on
9442    #[serde(skip_serializing_if = "Option::is_none")]
9443    pub modified_at: Option<Vec<String>>,
9444    ///Property: Detected names
9445    #[serde(skip_serializing_if = "Option::is_none")]
9446    pub names_mentioned: Option<Vec<String>>,
9447    ///Property: Source document
9448    #[serde(skip_serializing_if = "Option::is_none")]
9449    pub proof: Option<Vec<String>>,
9450    ///Property: Publishing source
9451    #[serde(skip_serializing_if = "Option::is_none")]
9452    pub publisher: Option<Vec<String>>,
9453    ///Property: Publishing source URL
9454    #[serde(skip_serializing_if = "Option::is_none")]
9455    pub publisher_url: Option<Vec<String>>,
9456    ///Property: Record ID
9457    #[serde(skip_serializing_if = "Option::is_none")]
9458    pub record_id: Option<Vec<String>>,
9459    ///Property: Retrieved on
9460    #[serde(skip_serializing_if = "Option::is_none")]
9461    pub retrieved_at: Option<Vec<String>>,
9462    ///Property: Role
9463    #[serde(skip_serializing_if = "Option::is_none")]
9464    pub role: Option<Vec<String>>,
9465    ///Property: Source link
9466    #[serde(skip_serializing_if = "Option::is_none")]
9467    pub source_url: Option<Vec<String>>,
9468    ///Property: Start date
9469    #[serde(skip_serializing_if = "Option::is_none")]
9470    pub start_date: Option<Vec<String>>,
9471    ///Property: Status
9472    #[serde(skip_serializing_if = "Option::is_none")]
9473    pub status: Option<Vec<String>>,
9474    ///Property: Summary
9475    #[serde(skip_serializing_if = "Option::is_none")]
9476    pub summary: Option<Vec<String>>,
9477}
9478impl Representation {
9479    /// Create a new entity with the given ID
9480    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
9481    pub fn new(id: impl Into<String>) -> Self {
9482        Self {
9483            id: id.into(),
9484            schema: "Representation".to_string(),
9485            agent: Vec::new(),
9486            aleph_url: None,
9487            client: Vec::new(),
9488            date: None,
9489            description: None,
9490            end_date: None,
9491            index_text: None,
9492            modified_at: None,
9493            names_mentioned: None,
9494            proof: None,
9495            publisher: None,
9496            publisher_url: None,
9497            record_id: None,
9498            retrieved_at: None,
9499            role: None,
9500            source_url: None,
9501            start_date: None,
9502            status: None,
9503            summary: None,
9504        }
9505    }
9506    /// Get the schema name
9507    pub fn schema_name() -> &'static str {
9508        "Representation"
9509    }
9510}
9511///FTM Schema: Risk
9512#[derive(Debug, Clone, Serialize, Deserialize)]
9513#[cfg_attr(feature = "builder", derive(Builder))]
9514#[serde(rename_all = "camelCase")]
9515pub struct Risk {
9516    pub id: String,
9517    #[cfg_attr(feature = "builder", builder(default = "Risk".to_string()))]
9518    pub schema: String,
9519    ///Property: Aleph URL
9520    #[serde(skip_serializing_if = "Option::is_none")]
9521    pub aleph_url: Option<Vec<String>>,
9522    ///Property: Country
9523    #[serde(skip_serializing_if = "Option::is_none")]
9524    pub country: Option<Vec<String>>,
9525    ///Property: Date
9526    #[serde(skip_serializing_if = "Option::is_none")]
9527    pub date: Option<Vec<String>>,
9528    ///Property: Description
9529    #[serde(skip_serializing_if = "Option::is_none")]
9530    pub description: Option<Vec<String>>,
9531    ///Property: Duration
9532    #[serde(
9533        skip_serializing_if = "Option::is_none",
9534        deserialize_with = "deserialize_opt_f64_vec",
9535        default
9536    )]
9537    pub duration: Option<Vec<f64>>,
9538    ///Property: End date
9539    #[serde(skip_serializing_if = "Option::is_none")]
9540    pub end_date: Option<Vec<String>>,
9541    ///Property: Entity
9542    #[serde(default)]
9543    pub entity: Vec<String>,
9544    ///Property: Index text
9545    #[serde(skip_serializing_if = "Option::is_none")]
9546    pub index_text: Option<Vec<String>>,
9547    ///Property: Listing date
9548    #[serde(skip_serializing_if = "Option::is_none")]
9549    pub listing_date: Option<Vec<String>>,
9550    ///Property: Modified on
9551    #[serde(skip_serializing_if = "Option::is_none")]
9552    pub modified_at: Option<Vec<String>>,
9553    ///Property: Detected names
9554    #[serde(skip_serializing_if = "Option::is_none")]
9555    pub names_mentioned: Option<Vec<String>>,
9556    ///Property: Source document
9557    #[serde(skip_serializing_if = "Option::is_none")]
9558    pub proof: Option<Vec<String>>,
9559    ///Property: Publishing source
9560    #[serde(skip_serializing_if = "Option::is_none")]
9561    pub publisher: Option<Vec<String>>,
9562    ///Property: Publishing source URL
9563    #[serde(skip_serializing_if = "Option::is_none")]
9564    pub publisher_url: Option<Vec<String>>,
9565    ///Property: Reason
9566    #[serde(skip_serializing_if = "Option::is_none")]
9567    pub reason: Option<Vec<String>>,
9568    ///Property: Record ID
9569    #[serde(skip_serializing_if = "Option::is_none")]
9570    pub record_id: Option<Vec<String>>,
9571    ///Property: Retrieved on
9572    #[serde(skip_serializing_if = "Option::is_none")]
9573    pub retrieved_at: Option<Vec<String>>,
9574    ///Property: Source link
9575    #[serde(skip_serializing_if = "Option::is_none")]
9576    pub source_url: Option<Vec<String>>,
9577    ///Property: Start date
9578    #[serde(skip_serializing_if = "Option::is_none")]
9579    pub start_date: Option<Vec<String>>,
9580    ///Property: Status
9581    #[serde(skip_serializing_if = "Option::is_none")]
9582    pub status: Option<Vec<String>>,
9583    ///Property: Summary
9584    #[serde(skip_serializing_if = "Option::is_none")]
9585    pub summary: Option<Vec<String>>,
9586    ///Property: Topics
9587    #[serde(skip_serializing_if = "Option::is_none")]
9588    pub topics: Option<Vec<String>>,
9589}
9590impl Risk {
9591    /// Create a new entity with the given ID
9592    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
9593    pub fn new(id: impl Into<String>) -> Self {
9594        Self {
9595            id: id.into(),
9596            schema: "Risk".to_string(),
9597            aleph_url: None,
9598            country: None,
9599            date: None,
9600            description: None,
9601            duration: None,
9602            end_date: None,
9603            entity: Vec::new(),
9604            index_text: None,
9605            listing_date: None,
9606            modified_at: None,
9607            names_mentioned: None,
9608            proof: None,
9609            publisher: None,
9610            publisher_url: None,
9611            reason: None,
9612            record_id: None,
9613            retrieved_at: None,
9614            source_url: None,
9615            start_date: None,
9616            status: None,
9617            summary: None,
9618            topics: None,
9619        }
9620    }
9621    /// Get the schema name
9622    pub fn schema_name() -> &'static str {
9623        "Risk"
9624    }
9625}
9626///FTM Schema: Sanction
9627#[derive(Debug, Clone, Serialize, Deserialize)]
9628#[cfg_attr(feature = "builder", derive(Builder))]
9629#[serde(rename_all = "camelCase")]
9630pub struct Sanction {
9631    pub id: String,
9632    #[cfg_attr(feature = "builder", builder(default = "Sanction".to_string()))]
9633    pub schema: String,
9634    ///Property: Aleph URL
9635    #[serde(skip_serializing_if = "Option::is_none")]
9636    pub aleph_url: Option<Vec<String>>,
9637    ///Property: Authority
9638    #[serde(skip_serializing_if = "Option::is_none")]
9639    pub authority: Option<Vec<String>>,
9640    ///Property: Authority-issued identifier
9641    #[serde(skip_serializing_if = "Option::is_none")]
9642    pub authority_id: Option<Vec<String>>,
9643    ///Property: Country
9644    #[serde(skip_serializing_if = "Option::is_none")]
9645    pub country: Option<Vec<String>>,
9646    ///Property: Date
9647    #[serde(skip_serializing_if = "Option::is_none")]
9648    pub date: Option<Vec<String>>,
9649    ///Property: Description
9650    #[serde(skip_serializing_if = "Option::is_none")]
9651    pub description: Option<Vec<String>>,
9652    ///Property: Duration
9653    #[serde(
9654        skip_serializing_if = "Option::is_none",
9655        deserialize_with = "deserialize_opt_f64_vec",
9656        default
9657    )]
9658    pub duration: Option<Vec<f64>>,
9659    ///Property: End date
9660    #[serde(skip_serializing_if = "Option::is_none")]
9661    pub end_date: Option<Vec<String>>,
9662    ///Property: Entity
9663    #[serde(default)]
9664    pub entity: Vec<String>,
9665    ///Property: Index text
9666    #[serde(skip_serializing_if = "Option::is_none")]
9667    pub index_text: Option<Vec<String>>,
9668    ///Property: Listing date
9669    #[serde(skip_serializing_if = "Option::is_none")]
9670    pub listing_date: Option<Vec<String>>,
9671    ///Property: Modified on
9672    #[serde(skip_serializing_if = "Option::is_none")]
9673    pub modified_at: Option<Vec<String>>,
9674    ///Property: Detected names
9675    #[serde(skip_serializing_if = "Option::is_none")]
9676    pub names_mentioned: Option<Vec<String>>,
9677    ///Property: Program
9678    #[serde(skip_serializing_if = "Option::is_none")]
9679    pub program: Option<Vec<String>>,
9680    ///Property: Program ID
9681    #[serde(skip_serializing_if = "Option::is_none")]
9682    pub program_id: Option<Vec<String>>,
9683    ///Property: Program URL
9684    #[serde(skip_serializing_if = "Option::is_none")]
9685    pub program_url: Option<Vec<String>>,
9686    ///Property: Source document
9687    #[serde(skip_serializing_if = "Option::is_none")]
9688    pub proof: Option<Vec<String>>,
9689    ///Property: Scope of sanctions
9690    #[serde(skip_serializing_if = "Option::is_none")]
9691    pub provisions: Option<Vec<String>>,
9692    ///Property: Publishing source
9693    #[serde(skip_serializing_if = "Option::is_none")]
9694    pub publisher: Option<Vec<String>>,
9695    ///Property: Publishing source URL
9696    #[serde(skip_serializing_if = "Option::is_none")]
9697    pub publisher_url: Option<Vec<String>>,
9698    ///Property: Reason
9699    #[serde(skip_serializing_if = "Option::is_none")]
9700    pub reason: Option<Vec<String>>,
9701    ///Property: Record ID
9702    #[serde(skip_serializing_if = "Option::is_none")]
9703    pub record_id: Option<Vec<String>>,
9704    ///Property: Retrieved on
9705    #[serde(skip_serializing_if = "Option::is_none")]
9706    pub retrieved_at: Option<Vec<String>>,
9707    ///Property: Source link
9708    #[serde(skip_serializing_if = "Option::is_none")]
9709    pub source_url: Option<Vec<String>>,
9710    ///Property: Start date
9711    #[serde(skip_serializing_if = "Option::is_none")]
9712    pub start_date: Option<Vec<String>>,
9713    ///Property: Status
9714    #[serde(skip_serializing_if = "Option::is_none")]
9715    pub status: Option<Vec<String>>,
9716    ///Property: Summary
9717    #[serde(skip_serializing_if = "Option::is_none")]
9718    pub summary: Option<Vec<String>>,
9719    ///Property: UN SC identifier
9720    #[serde(skip_serializing_if = "Option::is_none")]
9721    pub unsc_id: Option<Vec<String>>,
9722}
9723impl Sanction {
9724    /// Create a new entity with the given ID
9725    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
9726    pub fn new(id: impl Into<String>) -> Self {
9727        Self {
9728            id: id.into(),
9729            schema: "Sanction".to_string(),
9730            aleph_url: None,
9731            authority: None,
9732            authority_id: None,
9733            country: None,
9734            date: None,
9735            description: None,
9736            duration: None,
9737            end_date: None,
9738            entity: Vec::new(),
9739            index_text: None,
9740            listing_date: None,
9741            modified_at: None,
9742            names_mentioned: None,
9743            program: None,
9744            program_id: None,
9745            program_url: None,
9746            proof: None,
9747            provisions: None,
9748            publisher: None,
9749            publisher_url: None,
9750            reason: None,
9751            record_id: None,
9752            retrieved_at: None,
9753            source_url: None,
9754            start_date: None,
9755            status: None,
9756            summary: None,
9757            unsc_id: None,
9758        }
9759    }
9760    /// Get the schema name
9761    pub fn schema_name() -> &'static str {
9762        "Sanction"
9763    }
9764}
9765///FTM Schema: Security
9766#[derive(Debug, Clone, Serialize, Deserialize)]
9767#[cfg_attr(feature = "builder", derive(Builder))]
9768#[serde(rename_all = "camelCase")]
9769pub struct Security {
9770    pub id: String,
9771    #[cfg_attr(feature = "builder", builder(default = "Security".to_string()))]
9772    pub schema: String,
9773    ///Property: Address
9774    #[serde(skip_serializing_if = "Option::is_none")]
9775    pub address: Option<Vec<String>>,
9776    ///Property: Address
9777    #[serde(skip_serializing_if = "Option::is_none")]
9778    pub address_entity: Option<Vec<String>>,
9779    ///Property: Aleph URL
9780    #[serde(skip_serializing_if = "Option::is_none")]
9781    pub aleph_url: Option<Vec<String>>,
9782    ///Property: Alias
9783    #[serde(skip_serializing_if = "Option::is_none")]
9784    pub alias: Option<Vec<String>>,
9785    ///Property: Amount
9786    #[serde(
9787        skip_serializing_if = "Option::is_none",
9788        deserialize_with = "deserialize_opt_f64_vec",
9789        default
9790    )]
9791    pub amount: Option<Vec<f64>>,
9792    ///Property: Amount in EUR
9793    #[serde(
9794        skip_serializing_if = "Option::is_none",
9795        deserialize_with = "deserialize_opt_f64_vec",
9796        default
9797    )]
9798    pub amount_eur: Option<Vec<f64>>,
9799    ///Property: Amount in USD
9800    #[serde(
9801        skip_serializing_if = "Option::is_none",
9802        deserialize_with = "deserialize_opt_f64_vec",
9803        default
9804    )]
9805    pub amount_usd: Option<Vec<f64>>,
9806    ///Property: Classification
9807    #[serde(skip_serializing_if = "Option::is_none")]
9808    pub classification: Option<Vec<String>>,
9809    ///Property: Collateral
9810    #[serde(skip_serializing_if = "Option::is_none")]
9811    pub collateral: Option<Vec<String>>,
9812    ///Property: Country
9813    #[serde(skip_serializing_if = "Option::is_none")]
9814    pub country: Option<Vec<String>>,
9815    ///Property: Created at
9816    #[serde(skip_serializing_if = "Option::is_none")]
9817    pub created_at: Option<Vec<String>>,
9818    ///Property: Currency
9819    #[serde(skip_serializing_if = "Option::is_none")]
9820    pub currency: Option<Vec<String>>,
9821    ///Property: Description
9822    #[serde(skip_serializing_if = "Option::is_none")]
9823    pub description: Option<Vec<String>>,
9824    ///Property: Financial Instrument Global Identifier
9825    #[serde(skip_serializing_if = "Option::is_none")]
9826    pub figi_code: Option<Vec<String>>,
9827    ///Property: Index text
9828    #[serde(skip_serializing_if = "Option::is_none")]
9829    pub index_text: Option<Vec<String>>,
9830    ///Property: ISIN
9831    #[serde(skip_serializing_if = "Option::is_none")]
9832    pub isin: Option<Vec<String>>,
9833    ///Property: Date issued
9834    #[serde(skip_serializing_if = "Option::is_none")]
9835    pub issue_date: Option<Vec<String>>,
9836    ///Property: Issuer
9837    #[serde(skip_serializing_if = "Option::is_none")]
9838    pub issuer: Option<Vec<String>>,
9839    ///Property: Keywords
9840    #[serde(skip_serializing_if = "Option::is_none")]
9841    pub keywords: Option<Vec<String>>,
9842    ///Property: Maturity date
9843    #[serde(skip_serializing_if = "Option::is_none")]
9844    pub maturity_date: Option<Vec<String>>,
9845    ///Property: Modified on
9846    #[serde(skip_serializing_if = "Option::is_none")]
9847    pub modified_at: Option<Vec<String>>,
9848    ///Property: Name
9849    #[serde(default)]
9850    pub name: Vec<String>,
9851    ///Property: Notes
9852    #[serde(skip_serializing_if = "Option::is_none")]
9853    pub notes: Option<Vec<String>>,
9854    ///Property: Previous name
9855    #[serde(skip_serializing_if = "Option::is_none")]
9856    pub previous_name: Option<Vec<String>>,
9857    ///Property: Program
9858    #[serde(skip_serializing_if = "Option::is_none")]
9859    pub program: Option<Vec<String>>,
9860    ///Property: Program ID
9861    #[serde(skip_serializing_if = "Option::is_none")]
9862    pub program_id: Option<Vec<String>>,
9863    ///Property: Source document
9864    #[serde(skip_serializing_if = "Option::is_none")]
9865    pub proof: Option<Vec<String>>,
9866    ///Property: Publishing source
9867    #[serde(skip_serializing_if = "Option::is_none")]
9868    pub publisher: Option<Vec<String>>,
9869    ///Property: Publishing source URL
9870    #[serde(skip_serializing_if = "Option::is_none")]
9871    pub publisher_url: Option<Vec<String>>,
9872    ///Property: Registration number
9873    #[serde(skip_serializing_if = "Option::is_none")]
9874    pub registration_number: Option<Vec<String>>,
9875    ///Property: Retrieved on
9876    #[serde(skip_serializing_if = "Option::is_none")]
9877    pub retrieved_at: Option<Vec<String>>,
9878    ///Property: Source link
9879    #[serde(skip_serializing_if = "Option::is_none")]
9880    pub source_url: Option<Vec<String>>,
9881    ///Property: Summary
9882    #[serde(skip_serializing_if = "Option::is_none")]
9883    pub summary: Option<Vec<String>>,
9884    ///Property: Stock ticker symbol
9885    #[serde(skip_serializing_if = "Option::is_none")]
9886    pub ticker: Option<Vec<String>>,
9887    ///Property: Topics
9888    #[serde(skip_serializing_if = "Option::is_none")]
9889    pub topics: Option<Vec<String>>,
9890    ///Property: Type
9891    #[serde(skip_serializing_if = "Option::is_none")]
9892    pub type_: Option<Vec<String>>,
9893    ///Property: Weak alias
9894    #[serde(skip_serializing_if = "Option::is_none")]
9895    pub weak_alias: Option<Vec<String>>,
9896    ///Property: Wikidata ID
9897    #[serde(skip_serializing_if = "Option::is_none")]
9898    pub wikidata_id: Option<Vec<String>>,
9899    ///Property: Wikipedia Article
9900    #[serde(skip_serializing_if = "Option::is_none")]
9901    pub wikipedia_url: Option<Vec<String>>,
9902}
9903impl Security {
9904    /// Create a new entity with the given ID
9905    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
9906    pub fn new(id: impl Into<String>) -> Self {
9907        Self {
9908            id: id.into(),
9909            schema: "Security".to_string(),
9910            address: None,
9911            address_entity: None,
9912            aleph_url: None,
9913            alias: None,
9914            amount: None,
9915            amount_eur: None,
9916            amount_usd: None,
9917            classification: None,
9918            collateral: None,
9919            country: None,
9920            created_at: None,
9921            currency: None,
9922            description: None,
9923            figi_code: None,
9924            index_text: None,
9925            isin: None,
9926            issue_date: None,
9927            issuer: None,
9928            keywords: None,
9929            maturity_date: None,
9930            modified_at: None,
9931            name: Vec::new(),
9932            notes: None,
9933            previous_name: None,
9934            program: None,
9935            program_id: None,
9936            proof: None,
9937            publisher: None,
9938            publisher_url: None,
9939            registration_number: None,
9940            retrieved_at: None,
9941            source_url: None,
9942            summary: None,
9943            ticker: None,
9944            topics: None,
9945            type_: None,
9946            weak_alias: None,
9947            wikidata_id: None,
9948            wikipedia_url: None,
9949        }
9950    }
9951    /// Get the schema name
9952    pub fn schema_name() -> &'static str {
9953        "Security"
9954    }
9955}
9956///FTM Schema: Similar
9957#[derive(Debug, Clone, Serialize, Deserialize)]
9958#[cfg_attr(feature = "builder", derive(Builder))]
9959#[serde(rename_all = "camelCase")]
9960pub struct Similar {
9961    pub id: String,
9962    #[cfg_attr(feature = "builder", builder(default = "Similar".to_string()))]
9963    pub schema: String,
9964    ///Property: Candidate
9965    #[serde(skip_serializing_if = "Option::is_none")]
9966    pub candidate: Option<Vec<String>>,
9967    ///Property: Confidence score
9968    #[serde(
9969        skip_serializing_if = "Option::is_none",
9970        deserialize_with = "deserialize_opt_f64_vec",
9971        default
9972    )]
9973    pub confidence_score: Option<Vec<f64>>,
9974    ///Property: Matching criteria
9975    #[serde(skip_serializing_if = "Option::is_none")]
9976    pub criteria: Option<Vec<String>>,
9977    ///Property: Match
9978    #[serde(skip_serializing_if = "Option::is_none")]
9979    pub match_: Option<Vec<String>>,
9980    ///Property: Matcher
9981    #[serde(skip_serializing_if = "Option::is_none")]
9982    pub matcher: Option<Vec<String>>,
9983}
9984impl Similar {
9985    /// Create a new entity with the given ID
9986    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
9987    pub fn new(id: impl Into<String>) -> Self {
9988        Self {
9989            id: id.into(),
9990            schema: "Similar".to_string(),
9991            candidate: None,
9992            confidence_score: None,
9993            criteria: None,
9994            match_: None,
9995            matcher: None,
9996        }
9997    }
9998    /// Get the schema name
9999    pub fn schema_name() -> &'static str {
10000        "Similar"
10001    }
10002}
10003///FTM Schema: Succession
10004#[derive(Debug, Clone, Serialize, Deserialize)]
10005#[cfg_attr(feature = "builder", derive(Builder))]
10006#[serde(rename_all = "camelCase")]
10007pub struct Succession {
10008    pub id: String,
10009    #[cfg_attr(feature = "builder", builder(default = "Succession".to_string()))]
10010    pub schema: String,
10011    ///Property: Aleph URL
10012    #[serde(skip_serializing_if = "Option::is_none")]
10013    pub aleph_url: Option<Vec<String>>,
10014    ///Property: Date
10015    #[serde(skip_serializing_if = "Option::is_none")]
10016    pub date: Option<Vec<String>>,
10017    ///Property: Description
10018    #[serde(skip_serializing_if = "Option::is_none")]
10019    pub description: Option<Vec<String>>,
10020    ///Property: End date
10021    #[serde(skip_serializing_if = "Option::is_none")]
10022    pub end_date: Option<Vec<String>>,
10023    ///Property: Index text
10024    #[serde(skip_serializing_if = "Option::is_none")]
10025    pub index_text: Option<Vec<String>>,
10026    ///Property: Modified on
10027    #[serde(skip_serializing_if = "Option::is_none")]
10028    pub modified_at: Option<Vec<String>>,
10029    ///Property: Detected names
10030    #[serde(skip_serializing_if = "Option::is_none")]
10031    pub names_mentioned: Option<Vec<String>>,
10032    ///Property: Predecessor
10033    #[serde(default)]
10034    pub predecessor: Vec<String>,
10035    ///Property: Source document
10036    #[serde(skip_serializing_if = "Option::is_none")]
10037    pub proof: Option<Vec<String>>,
10038    ///Property: Publishing source
10039    #[serde(skip_serializing_if = "Option::is_none")]
10040    pub publisher: Option<Vec<String>>,
10041    ///Property: Publishing source URL
10042    #[serde(skip_serializing_if = "Option::is_none")]
10043    pub publisher_url: Option<Vec<String>>,
10044    ///Property: Record ID
10045    #[serde(skip_serializing_if = "Option::is_none")]
10046    pub record_id: Option<Vec<String>>,
10047    ///Property: Retrieved on
10048    #[serde(skip_serializing_if = "Option::is_none")]
10049    pub retrieved_at: Option<Vec<String>>,
10050    ///Property: Role
10051    #[serde(skip_serializing_if = "Option::is_none")]
10052    pub role: Option<Vec<String>>,
10053    ///Property: Source link
10054    #[serde(skip_serializing_if = "Option::is_none")]
10055    pub source_url: Option<Vec<String>>,
10056    ///Property: Start date
10057    #[serde(skip_serializing_if = "Option::is_none")]
10058    pub start_date: Option<Vec<String>>,
10059    ///Property: Status
10060    #[serde(skip_serializing_if = "Option::is_none")]
10061    pub status: Option<Vec<String>>,
10062    ///Property: Successor
10063    #[serde(default)]
10064    pub successor: Vec<String>,
10065    ///Property: Summary
10066    #[serde(skip_serializing_if = "Option::is_none")]
10067    pub summary: Option<Vec<String>>,
10068}
10069impl Succession {
10070    /// Create a new entity with the given ID
10071    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
10072    pub fn new(id: impl Into<String>) -> Self {
10073        Self {
10074            id: id.into(),
10075            schema: "Succession".to_string(),
10076            aleph_url: None,
10077            date: None,
10078            description: None,
10079            end_date: None,
10080            index_text: None,
10081            modified_at: None,
10082            names_mentioned: None,
10083            predecessor: Vec::new(),
10084            proof: None,
10085            publisher: None,
10086            publisher_url: None,
10087            record_id: None,
10088            retrieved_at: None,
10089            role: None,
10090            source_url: None,
10091            start_date: None,
10092            status: None,
10093            successor: Vec::new(),
10094            summary: None,
10095        }
10096    }
10097    /// Get the schema name
10098    pub fn schema_name() -> &'static str {
10099        "Succession"
10100    }
10101}
10102///FTM Schema: Table
10103#[derive(Debug, Clone, Serialize, Deserialize)]
10104#[cfg_attr(feature = "builder", derive(Builder))]
10105#[serde(rename_all = "camelCase")]
10106pub struct Table {
10107    pub id: String,
10108    #[cfg_attr(feature = "builder", builder(default = "Table".to_string()))]
10109    pub schema: String,
10110    ///Property: Address
10111    #[serde(skip_serializing_if = "Option::is_none")]
10112    pub address: Option<Vec<String>>,
10113    ///Property: Address
10114    #[serde(skip_serializing_if = "Option::is_none")]
10115    pub address_entity: Option<Vec<String>>,
10116    ///Property: Aleph URL
10117    #[serde(skip_serializing_if = "Option::is_none")]
10118    pub aleph_url: Option<Vec<String>>,
10119    ///Property: Alias
10120    #[serde(skip_serializing_if = "Option::is_none")]
10121    pub alias: Option<Vec<String>>,
10122    ///Property: Ancestors
10123    #[serde(skip_serializing_if = "Option::is_none")]
10124    pub ancestors: Option<Vec<String>>,
10125    ///Property: Author
10126    #[serde(skip_serializing_if = "Option::is_none")]
10127    pub author: Option<Vec<String>>,
10128    ///Property: Authored on
10129    #[serde(skip_serializing_if = "Option::is_none")]
10130    pub authored_at: Option<Vec<String>>,
10131    ///Property: Text
10132    #[serde(skip_serializing_if = "Option::is_none")]
10133    pub body_text: Option<Vec<String>>,
10134    ///Property: Column headings
10135    #[serde(skip_serializing_if = "Option::is_none")]
10136    pub columns: Option<serde_json::Value>,
10137    ///Property: Detected companies
10138    #[serde(skip_serializing_if = "Option::is_none")]
10139    pub companies_mentioned: Option<Vec<String>>,
10140    ///Property: Checksum
10141    #[serde(skip_serializing_if = "Option::is_none")]
10142    pub content_hash: Option<Vec<String>>,
10143    ///Property: Country
10144    #[serde(skip_serializing_if = "Option::is_none")]
10145    pub country: Option<Vec<String>>,
10146    ///Property: Crawler
10147    #[serde(skip_serializing_if = "Option::is_none")]
10148    pub crawler: Option<Vec<String>>,
10149    ///Property: Created at
10150    #[serde(skip_serializing_if = "Option::is_none")]
10151    pub created_at: Option<Vec<String>>,
10152    ///Property: CSV alternative version checksum
10153    #[serde(skip_serializing_if = "Option::is_none")]
10154    pub csv_hash: Option<Vec<String>>,
10155    ///Property: Date
10156    #[serde(skip_serializing_if = "Option::is_none")]
10157    pub date: Option<Vec<String>>,
10158    ///Property: Description
10159    #[serde(skip_serializing_if = "Option::is_none")]
10160    pub description: Option<Vec<String>>,
10161    ///Property: Detected country
10162    #[serde(skip_serializing_if = "Option::is_none")]
10163    pub detected_country: Option<Vec<String>>,
10164    ///Property: Detected language
10165    #[serde(skip_serializing_if = "Option::is_none")]
10166    pub detected_language: Option<Vec<String>>,
10167    ///Property: Detected e-mail addresses
10168    #[serde(skip_serializing_if = "Option::is_none")]
10169    pub email_mentioned: Option<Vec<String>>,
10170    ///Property: File encoding
10171    #[serde(skip_serializing_if = "Option::is_none")]
10172    pub encoding: Option<Vec<String>>,
10173    ///Property: File extension
10174    #[serde(skip_serializing_if = "Option::is_none")]
10175    pub extension: Option<Vec<String>>,
10176    ///Property: File name
10177    #[serde(default)]
10178    pub file_name: Vec<String>,
10179    ///Property: File size
10180    #[serde(
10181        skip_serializing_if = "Option::is_none",
10182        deserialize_with = "deserialize_opt_f64_vec",
10183        default
10184    )]
10185    pub file_size: Option<Vec<f64>>,
10186    ///Property: Generator
10187    #[serde(skip_serializing_if = "Option::is_none")]
10188    pub generator: Option<Vec<String>>,
10189    ///Property: Detected IBANs
10190    #[serde(skip_serializing_if = "Option::is_none")]
10191    pub iban_mentioned: Option<Vec<String>>,
10192    ///Property: Index text
10193    #[serde(skip_serializing_if = "Option::is_none")]
10194    pub index_text: Option<Vec<String>>,
10195    ///Property: Detected IP addresses
10196    #[serde(skip_serializing_if = "Option::is_none")]
10197    pub ip_mentioned: Option<Vec<String>>,
10198    ///Property: Keywords
10199    #[serde(skip_serializing_if = "Option::is_none")]
10200    pub keywords: Option<Vec<String>>,
10201    ///Property: Language
10202    #[serde(skip_serializing_if = "Option::is_none")]
10203    pub language: Option<Vec<String>>,
10204    ///Property: Detected locations
10205    #[serde(skip_serializing_if = "Option::is_none")]
10206    pub location_mentioned: Option<Vec<String>>,
10207    ///Property: Message ID
10208    #[serde(skip_serializing_if = "Option::is_none")]
10209    pub message_id: Option<Vec<String>>,
10210    ///Property: MIME type
10211    #[serde(skip_serializing_if = "Option::is_none")]
10212    pub mime_type: Option<Vec<String>>,
10213    ///Property: Modified on
10214    #[serde(skip_serializing_if = "Option::is_none")]
10215    pub modified_at: Option<Vec<String>>,
10216    ///Property: Name
10217    #[serde(default)]
10218    pub name: Vec<String>,
10219    ///Property: Detected names
10220    #[serde(skip_serializing_if = "Option::is_none")]
10221    pub names_mentioned: Option<Vec<String>>,
10222    ///Property: Notes
10223    #[serde(skip_serializing_if = "Option::is_none")]
10224    pub notes: Option<Vec<String>>,
10225    ///Property: Folder
10226    #[serde(skip_serializing_if = "Option::is_none")]
10227    pub parent: Option<Vec<String>>,
10228    ///Property: Detected people
10229    #[serde(skip_serializing_if = "Option::is_none")]
10230    pub people_mentioned: Option<Vec<String>>,
10231    ///Property: Detected phones
10232    #[serde(skip_serializing_if = "Option::is_none")]
10233    pub phone_mentioned: Option<Vec<String>>,
10234    ///Property: Previous name
10235    #[serde(skip_serializing_if = "Option::is_none")]
10236    pub previous_name: Option<Vec<String>>,
10237    ///Property: Processed at
10238    #[serde(skip_serializing_if = "Option::is_none")]
10239    pub processed_at: Option<Vec<String>>,
10240    ///Property: Processing agent
10241    #[serde(skip_serializing_if = "Option::is_none")]
10242    pub processing_agent: Option<Vec<String>>,
10243    ///Property: Processing error
10244    #[serde(skip_serializing_if = "Option::is_none")]
10245    pub processing_error: Option<Vec<String>>,
10246    ///Property: Processing status
10247    #[serde(skip_serializing_if = "Option::is_none")]
10248    pub processing_status: Option<Vec<String>>,
10249    ///Property: Program
10250    #[serde(skip_serializing_if = "Option::is_none")]
10251    pub program: Option<Vec<String>>,
10252    ///Property: Program ID
10253    #[serde(skip_serializing_if = "Option::is_none")]
10254    pub program_id: Option<Vec<String>>,
10255    ///Property: Source document
10256    #[serde(skip_serializing_if = "Option::is_none")]
10257    pub proof: Option<Vec<String>>,
10258    ///Property: Published on
10259    #[serde(skip_serializing_if = "Option::is_none")]
10260    pub published_at: Option<Vec<String>>,
10261    ///Property: Publishing source
10262    #[serde(skip_serializing_if = "Option::is_none")]
10263    pub publisher: Option<Vec<String>>,
10264    ///Property: Publishing source URL
10265    #[serde(skip_serializing_if = "Option::is_none")]
10266    pub publisher_url: Option<Vec<String>>,
10267    ///Property: Retrieved on
10268    #[serde(skip_serializing_if = "Option::is_none")]
10269    pub retrieved_at: Option<Vec<String>>,
10270    ///Property: Number of rows
10271    #[serde(
10272        skip_serializing_if = "Option::is_none",
10273        deserialize_with = "deserialize_opt_f64_vec",
10274        default
10275    )]
10276    pub row_count: Option<Vec<f64>>,
10277    ///Property: Source link
10278    #[serde(skip_serializing_if = "Option::is_none")]
10279    pub source_url: Option<Vec<String>>,
10280    ///Property: Summary
10281    #[serde(skip_serializing_if = "Option::is_none")]
10282    pub summary: Option<Vec<String>>,
10283    ///Property: Title
10284    #[serde(skip_serializing_if = "Option::is_none")]
10285    pub title: Option<Vec<String>>,
10286    ///Property: Topics
10287    #[serde(skip_serializing_if = "Option::is_none")]
10288    pub topics: Option<Vec<String>>,
10289    ///Property: The language of the translated text
10290    #[serde(skip_serializing_if = "Option::is_none")]
10291    pub translated_language: Option<Vec<String>>,
10292    ///Property: Translated version of the body text
10293    #[serde(skip_serializing_if = "Option::is_none")]
10294    pub translated_text: Option<Vec<String>>,
10295    ///Property: Weak alias
10296    #[serde(skip_serializing_if = "Option::is_none")]
10297    pub weak_alias: Option<Vec<String>>,
10298    ///Property: Wikidata ID
10299    #[serde(skip_serializing_if = "Option::is_none")]
10300    pub wikidata_id: Option<Vec<String>>,
10301    ///Property: Wikipedia Article
10302    #[serde(skip_serializing_if = "Option::is_none")]
10303    pub wikipedia_url: Option<Vec<String>>,
10304}
10305impl Table {
10306    /// Create a new entity with the given ID
10307    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
10308    pub fn new(id: impl Into<String>) -> Self {
10309        Self {
10310            id: id.into(),
10311            schema: "Table".to_string(),
10312            address: None,
10313            address_entity: None,
10314            aleph_url: None,
10315            alias: None,
10316            ancestors: None,
10317            author: None,
10318            authored_at: None,
10319            body_text: None,
10320            columns: None,
10321            companies_mentioned: None,
10322            content_hash: None,
10323            country: None,
10324            crawler: None,
10325            created_at: None,
10326            csv_hash: None,
10327            date: None,
10328            description: None,
10329            detected_country: None,
10330            detected_language: None,
10331            email_mentioned: None,
10332            encoding: None,
10333            extension: None,
10334            file_name: Vec::new(),
10335            file_size: None,
10336            generator: None,
10337            iban_mentioned: None,
10338            index_text: None,
10339            ip_mentioned: None,
10340            keywords: None,
10341            language: None,
10342            location_mentioned: None,
10343            message_id: None,
10344            mime_type: None,
10345            modified_at: None,
10346            name: Vec::new(),
10347            names_mentioned: None,
10348            notes: None,
10349            parent: None,
10350            people_mentioned: None,
10351            phone_mentioned: None,
10352            previous_name: None,
10353            processed_at: None,
10354            processing_agent: None,
10355            processing_error: None,
10356            processing_status: None,
10357            program: None,
10358            program_id: None,
10359            proof: None,
10360            published_at: None,
10361            publisher: None,
10362            publisher_url: None,
10363            retrieved_at: None,
10364            row_count: None,
10365            source_url: None,
10366            summary: None,
10367            title: None,
10368            topics: None,
10369            translated_language: None,
10370            translated_text: None,
10371            weak_alias: None,
10372            wikidata_id: None,
10373            wikipedia_url: None,
10374        }
10375    }
10376    /// Get the schema name
10377    pub fn schema_name() -> &'static str {
10378        "Table"
10379    }
10380}
10381///FTM Schema: Tax roll
10382#[derive(Debug, Clone, Serialize, Deserialize)]
10383#[cfg_attr(feature = "builder", derive(Builder))]
10384#[serde(rename_all = "camelCase")]
10385pub struct TaxRoll {
10386    pub id: String,
10387    #[cfg_attr(feature = "builder", builder(default = "TaxRoll".to_string()))]
10388    pub schema: String,
10389    ///Property: Aleph URL
10390    #[serde(skip_serializing_if = "Option::is_none")]
10391    pub aleph_url: Option<Vec<String>>,
10392    ///Property: Birth date
10393    #[serde(skip_serializing_if = "Option::is_none")]
10394    pub birth_date: Option<Vec<String>>,
10395    ///Property: Country
10396    #[serde(skip_serializing_if = "Option::is_none")]
10397    pub country: Option<Vec<String>>,
10398    ///Property: Date
10399    #[serde(skip_serializing_if = "Option::is_none")]
10400    pub date: Option<Vec<String>>,
10401    ///Property: Description
10402    #[serde(skip_serializing_if = "Option::is_none")]
10403    pub description: Option<Vec<String>>,
10404    ///Property: End date
10405    #[serde(skip_serializing_if = "Option::is_none")]
10406    pub end_date: Option<Vec<String>>,
10407    ///Property: Given name
10408    #[serde(skip_serializing_if = "Option::is_none")]
10409    pub given_name: Option<Vec<String>>,
10410    ///Property: Registered income
10411    #[serde(skip_serializing_if = "Option::is_none")]
10412    pub income: Option<Vec<String>>,
10413    ///Property: Index text
10414    #[serde(skip_serializing_if = "Option::is_none")]
10415    pub index_text: Option<Vec<String>>,
10416    ///Property: Modified on
10417    #[serde(skip_serializing_if = "Option::is_none")]
10418    pub modified_at: Option<Vec<String>>,
10419    ///Property: Detected names
10420    #[serde(skip_serializing_if = "Option::is_none")]
10421    pub names_mentioned: Option<Vec<String>>,
10422    ///Property: Source document
10423    #[serde(skip_serializing_if = "Option::is_none")]
10424    pub proof: Option<Vec<String>>,
10425    ///Property: Publishing source
10426    #[serde(skip_serializing_if = "Option::is_none")]
10427    pub publisher: Option<Vec<String>>,
10428    ///Property: Publishing source URL
10429    #[serde(skip_serializing_if = "Option::is_none")]
10430    pub publisher_url: Option<Vec<String>>,
10431    ///Property: Record ID
10432    #[serde(skip_serializing_if = "Option::is_none")]
10433    pub record_id: Option<Vec<String>>,
10434    ///Property: Retrieved on
10435    #[serde(skip_serializing_if = "Option::is_none")]
10436    pub retrieved_at: Option<Vec<String>>,
10437    ///Property: Source link
10438    #[serde(skip_serializing_if = "Option::is_none")]
10439    pub source_url: Option<Vec<String>>,
10440    ///Property: Start date
10441    #[serde(skip_serializing_if = "Option::is_none")]
10442    pub start_date: Option<Vec<String>>,
10443    ///Property: Summary
10444    #[serde(skip_serializing_if = "Option::is_none")]
10445    pub summary: Option<Vec<String>>,
10446    ///Property: Surname
10447    #[serde(skip_serializing_if = "Option::is_none")]
10448    pub surname: Option<Vec<String>>,
10449    ///Property: Amount of tax paid
10450    #[serde(skip_serializing_if = "Option::is_none")]
10451    pub tax_paid: Option<Vec<String>>,
10452    ///Property: Taxee
10453    #[serde(default)]
10454    pub taxee: Vec<String>,
10455    ///Property: Registered wealth
10456    #[serde(skip_serializing_if = "Option::is_none")]
10457    pub wealth: Option<Vec<String>>,
10458}
10459impl TaxRoll {
10460    /// Create a new entity with the given ID
10461    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
10462    pub fn new(id: impl Into<String>) -> Self {
10463        Self {
10464            id: id.into(),
10465            schema: "TaxRoll".to_string(),
10466            aleph_url: None,
10467            birth_date: None,
10468            country: None,
10469            date: None,
10470            description: None,
10471            end_date: None,
10472            given_name: None,
10473            income: None,
10474            index_text: None,
10475            modified_at: None,
10476            names_mentioned: None,
10477            proof: None,
10478            publisher: None,
10479            publisher_url: None,
10480            record_id: None,
10481            retrieved_at: None,
10482            source_url: None,
10483            start_date: None,
10484            summary: None,
10485            surname: None,
10486            tax_paid: None,
10487            taxee: Vec::new(),
10488            wealth: None,
10489        }
10490    }
10491    /// Get the schema name
10492    pub fn schema_name() -> &'static str {
10493        "TaxRoll"
10494    }
10495}
10496///FTM Schema: Trip
10497#[derive(Debug, Clone, Serialize, Deserialize)]
10498#[cfg_attr(feature = "builder", derive(Builder))]
10499#[serde(rename_all = "camelCase")]
10500pub struct Trip {
10501    pub id: String,
10502    #[cfg_attr(feature = "builder", builder(default = "Trip".to_string()))]
10503    pub schema: String,
10504    ///Property: Address
10505    #[serde(skip_serializing_if = "Option::is_none")]
10506    pub address: Option<Vec<String>>,
10507    ///Property: Address
10508    #[serde(skip_serializing_if = "Option::is_none")]
10509    pub address_entity: Option<Vec<String>>,
10510    ///Property: Aleph URL
10511    #[serde(skip_serializing_if = "Option::is_none")]
10512    pub aleph_url: Option<Vec<String>>,
10513    ///Property: Alias
10514    #[serde(skip_serializing_if = "Option::is_none")]
10515    pub alias: Option<Vec<String>>,
10516    ///Property: Detected companies
10517    #[serde(skip_serializing_if = "Option::is_none")]
10518    pub companies_mentioned: Option<Vec<String>>,
10519    ///Property: Country
10520    #[serde(skip_serializing_if = "Option::is_none")]
10521    pub country: Option<Vec<String>>,
10522    ///Property: Created at
10523    #[serde(skip_serializing_if = "Option::is_none")]
10524    pub created_at: Option<Vec<String>>,
10525    ///Property: Date
10526    #[serde(skip_serializing_if = "Option::is_none")]
10527    pub date: Option<Vec<String>>,
10528    ///Property: Description
10529    #[serde(skip_serializing_if = "Option::is_none")]
10530    pub description: Option<Vec<String>>,
10531    ///Property: Detected country
10532    #[serde(skip_serializing_if = "Option::is_none")]
10533    pub detected_country: Option<Vec<String>>,
10534    ///Property: Detected language
10535    #[serde(skip_serializing_if = "Option::is_none")]
10536    pub detected_language: Option<Vec<String>>,
10537    ///Property: Detected e-mail addresses
10538    #[serde(skip_serializing_if = "Option::is_none")]
10539    pub email_mentioned: Option<Vec<String>>,
10540    ///Property: End date
10541    #[serde(skip_serializing_if = "Option::is_none")]
10542    pub end_date: Option<Vec<String>>,
10543    ///Property: End location
10544    #[serde(default)]
10545    pub end_location: Vec<String>,
10546    ///Property: Detected IBANs
10547    #[serde(skip_serializing_if = "Option::is_none")]
10548    pub iban_mentioned: Option<Vec<String>>,
10549    ///Property: Important
10550    #[serde(skip_serializing_if = "Option::is_none")]
10551    pub important: Option<Vec<String>>,
10552    ///Property: Index text
10553    #[serde(skip_serializing_if = "Option::is_none")]
10554    pub index_text: Option<Vec<String>>,
10555    ///Property: Involved
10556    #[serde(skip_serializing_if = "Option::is_none")]
10557    pub involved: Option<Vec<String>>,
10558    ///Property: Detected IP addresses
10559    #[serde(skip_serializing_if = "Option::is_none")]
10560    pub ip_mentioned: Option<Vec<String>>,
10561    ///Property: Keywords
10562    #[serde(skip_serializing_if = "Option::is_none")]
10563    pub keywords: Option<Vec<String>>,
10564    ///Property: Location
10565    #[serde(skip_serializing_if = "Option::is_none")]
10566    pub location: Option<Vec<String>>,
10567    ///Property: Detected locations
10568    #[serde(skip_serializing_if = "Option::is_none")]
10569    pub location_mentioned: Option<Vec<String>>,
10570    ///Property: Modified on
10571    #[serde(skip_serializing_if = "Option::is_none")]
10572    pub modified_at: Option<Vec<String>>,
10573    ///Property: Name
10574    #[serde(default)]
10575    pub name: Vec<String>,
10576    ///Property: Detected names
10577    #[serde(skip_serializing_if = "Option::is_none")]
10578    pub names_mentioned: Option<Vec<String>>,
10579    ///Property: Notes
10580    #[serde(skip_serializing_if = "Option::is_none")]
10581    pub notes: Option<Vec<String>>,
10582    ///Property: Organizer
10583    #[serde(skip_serializing_if = "Option::is_none")]
10584    pub organizer: Option<Vec<String>>,
10585    ///Property: Detected people
10586    #[serde(skip_serializing_if = "Option::is_none")]
10587    pub people_mentioned: Option<Vec<String>>,
10588    ///Property: Detected phones
10589    #[serde(skip_serializing_if = "Option::is_none")]
10590    pub phone_mentioned: Option<Vec<String>>,
10591    ///Property: Previous name
10592    #[serde(skip_serializing_if = "Option::is_none")]
10593    pub previous_name: Option<Vec<String>>,
10594    ///Property: Program
10595    #[serde(skip_serializing_if = "Option::is_none")]
10596    pub program: Option<Vec<String>>,
10597    ///Property: Program ID
10598    #[serde(skip_serializing_if = "Option::is_none")]
10599    pub program_id: Option<Vec<String>>,
10600    ///Property: Source document
10601    #[serde(skip_serializing_if = "Option::is_none")]
10602    pub proof: Option<Vec<String>>,
10603    ///Property: Publishing source
10604    #[serde(skip_serializing_if = "Option::is_none")]
10605    pub publisher: Option<Vec<String>>,
10606    ///Property: Publishing source URL
10607    #[serde(skip_serializing_if = "Option::is_none")]
10608    pub publisher_url: Option<Vec<String>>,
10609    ///Property: Record ID
10610    #[serde(skip_serializing_if = "Option::is_none")]
10611    pub record_id: Option<Vec<String>>,
10612    ///Property: Retrieved on
10613    #[serde(skip_serializing_if = "Option::is_none")]
10614    pub retrieved_at: Option<Vec<String>>,
10615    ///Property: Source link
10616    #[serde(skip_serializing_if = "Option::is_none")]
10617    pub source_url: Option<Vec<String>>,
10618    ///Property: Start date
10619    #[serde(skip_serializing_if = "Option::is_none")]
10620    pub start_date: Option<Vec<String>>,
10621    ///Property: Start location
10622    #[serde(default)]
10623    pub start_location: Vec<String>,
10624    ///Property: Summary
10625    #[serde(skip_serializing_if = "Option::is_none")]
10626    pub summary: Option<Vec<String>>,
10627    ///Property: Topics
10628    #[serde(skip_serializing_if = "Option::is_none")]
10629    pub topics: Option<Vec<String>>,
10630    ///Property: Vehicle
10631    #[serde(skip_serializing_if = "Option::is_none")]
10632    pub vehicle: Option<Vec<String>>,
10633    ///Property: Weak alias
10634    #[serde(skip_serializing_if = "Option::is_none")]
10635    pub weak_alias: Option<Vec<String>>,
10636    ///Property: Wikidata ID
10637    #[serde(skip_serializing_if = "Option::is_none")]
10638    pub wikidata_id: Option<Vec<String>>,
10639    ///Property: Wikipedia Article
10640    #[serde(skip_serializing_if = "Option::is_none")]
10641    pub wikipedia_url: Option<Vec<String>>,
10642}
10643impl Trip {
10644    /// Create a new entity with the given ID
10645    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
10646    pub fn new(id: impl Into<String>) -> Self {
10647        Self {
10648            id: id.into(),
10649            schema: "Trip".to_string(),
10650            address: None,
10651            address_entity: None,
10652            aleph_url: None,
10653            alias: None,
10654            companies_mentioned: None,
10655            country: None,
10656            created_at: None,
10657            date: None,
10658            description: None,
10659            detected_country: None,
10660            detected_language: None,
10661            email_mentioned: None,
10662            end_date: None,
10663            end_location: Vec::new(),
10664            iban_mentioned: None,
10665            important: None,
10666            index_text: None,
10667            involved: None,
10668            ip_mentioned: None,
10669            keywords: None,
10670            location: None,
10671            location_mentioned: None,
10672            modified_at: None,
10673            name: Vec::new(),
10674            names_mentioned: None,
10675            notes: None,
10676            organizer: None,
10677            people_mentioned: None,
10678            phone_mentioned: None,
10679            previous_name: None,
10680            program: None,
10681            program_id: None,
10682            proof: None,
10683            publisher: None,
10684            publisher_url: None,
10685            record_id: None,
10686            retrieved_at: None,
10687            source_url: None,
10688            start_date: None,
10689            start_location: Vec::new(),
10690            summary: None,
10691            topics: None,
10692            vehicle: None,
10693            weak_alias: None,
10694            wikidata_id: None,
10695            wikipedia_url: None,
10696        }
10697    }
10698    /// Get the schema name
10699    pub fn schema_name() -> &'static str {
10700        "Trip"
10701    }
10702}
10703///FTM Schema: Other link
10704#[derive(Debug, Clone, Serialize, Deserialize)]
10705#[cfg_attr(feature = "builder", derive(Builder))]
10706#[serde(rename_all = "camelCase")]
10707pub struct UnknownLink {
10708    pub id: String,
10709    #[cfg_attr(feature = "builder", builder(default = "UnknownLink".to_string()))]
10710    pub schema: String,
10711    ///Property: Aleph URL
10712    #[serde(skip_serializing_if = "Option::is_none")]
10713    pub aleph_url: Option<Vec<String>>,
10714    ///Property: Date
10715    #[serde(skip_serializing_if = "Option::is_none")]
10716    pub date: Option<Vec<String>>,
10717    ///Property: Description
10718    #[serde(skip_serializing_if = "Option::is_none")]
10719    pub description: Option<Vec<String>>,
10720    ///Property: End date
10721    #[serde(skip_serializing_if = "Option::is_none")]
10722    pub end_date: Option<Vec<String>>,
10723    ///Property: Index text
10724    #[serde(skip_serializing_if = "Option::is_none")]
10725    pub index_text: Option<Vec<String>>,
10726    ///Property: Modified on
10727    #[serde(skip_serializing_if = "Option::is_none")]
10728    pub modified_at: Option<Vec<String>>,
10729    ///Property: Detected names
10730    #[serde(skip_serializing_if = "Option::is_none")]
10731    pub names_mentioned: Option<Vec<String>>,
10732    ///Property: Object
10733    #[serde(default)]
10734    pub object: Vec<String>,
10735    ///Property: Source document
10736    #[serde(skip_serializing_if = "Option::is_none")]
10737    pub proof: Option<Vec<String>>,
10738    ///Property: Publishing source
10739    #[serde(skip_serializing_if = "Option::is_none")]
10740    pub publisher: Option<Vec<String>>,
10741    ///Property: Publishing source URL
10742    #[serde(skip_serializing_if = "Option::is_none")]
10743    pub publisher_url: Option<Vec<String>>,
10744    ///Property: Record ID
10745    #[serde(skip_serializing_if = "Option::is_none")]
10746    pub record_id: Option<Vec<String>>,
10747    ///Property: Retrieved on
10748    #[serde(skip_serializing_if = "Option::is_none")]
10749    pub retrieved_at: Option<Vec<String>>,
10750    ///Property: Role
10751    #[serde(skip_serializing_if = "Option::is_none")]
10752    pub role: Option<Vec<String>>,
10753    ///Property: Source link
10754    #[serde(skip_serializing_if = "Option::is_none")]
10755    pub source_url: Option<Vec<String>>,
10756    ///Property: Start date
10757    #[serde(skip_serializing_if = "Option::is_none")]
10758    pub start_date: Option<Vec<String>>,
10759    ///Property: Status
10760    #[serde(skip_serializing_if = "Option::is_none")]
10761    pub status: Option<Vec<String>>,
10762    ///Property: Subject
10763    #[serde(default)]
10764    pub subject: Vec<String>,
10765    ///Property: Summary
10766    #[serde(skip_serializing_if = "Option::is_none")]
10767    pub summary: Option<Vec<String>>,
10768}
10769impl UnknownLink {
10770    /// Create a new entity with the given ID
10771    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
10772    pub fn new(id: impl Into<String>) -> Self {
10773        Self {
10774            id: id.into(),
10775            schema: "UnknownLink".to_string(),
10776            aleph_url: None,
10777            date: None,
10778            description: None,
10779            end_date: None,
10780            index_text: None,
10781            modified_at: None,
10782            names_mentioned: None,
10783            object: Vec::new(),
10784            proof: None,
10785            publisher: None,
10786            publisher_url: None,
10787            record_id: None,
10788            retrieved_at: None,
10789            role: None,
10790            source_url: None,
10791            start_date: None,
10792            status: None,
10793            subject: Vec::new(),
10794            summary: None,
10795        }
10796    }
10797    /// Get the schema name
10798    pub fn schema_name() -> &'static str {
10799        "UnknownLink"
10800    }
10801}
10802///FTM Schema: User account
10803#[derive(Debug, Clone, Serialize, Deserialize)]
10804#[cfg_attr(feature = "builder", derive(Builder))]
10805#[serde(rename_all = "camelCase")]
10806pub struct UserAccount {
10807    pub id: String,
10808    #[cfg_attr(feature = "builder", builder(default = "UserAccount".to_string()))]
10809    pub schema: String,
10810    ///Property: Address
10811    #[serde(skip_serializing_if = "Option::is_none")]
10812    pub address: Option<Vec<String>>,
10813    ///Property: Address
10814    #[serde(skip_serializing_if = "Option::is_none")]
10815    pub address_entity: Option<Vec<String>>,
10816    ///Property: Aleph URL
10817    #[serde(skip_serializing_if = "Option::is_none")]
10818    pub aleph_url: Option<Vec<String>>,
10819    ///Property: Alias
10820    #[serde(skip_serializing_if = "Option::is_none")]
10821    pub alias: Option<Vec<String>>,
10822    ///Property: Country
10823    #[serde(skip_serializing_if = "Option::is_none")]
10824    pub country: Option<Vec<String>>,
10825    ///Property: Created at
10826    #[serde(skip_serializing_if = "Option::is_none")]
10827    pub created_at: Option<Vec<String>>,
10828    ///Property: Description
10829    #[serde(skip_serializing_if = "Option::is_none")]
10830    pub description: Option<Vec<String>>,
10831    ///Property: E-Mail
10832    #[serde(skip_serializing_if = "Option::is_none")]
10833    pub email: Option<Vec<String>>,
10834    ///Property: Index text
10835    #[serde(skip_serializing_if = "Option::is_none")]
10836    pub index_text: Option<Vec<String>>,
10837    ///Property: IP address
10838    #[serde(skip_serializing_if = "Option::is_none")]
10839    pub ip_address: Option<Vec<String>>,
10840    ///Property: Keywords
10841    #[serde(skip_serializing_if = "Option::is_none")]
10842    pub keywords: Option<Vec<String>>,
10843    ///Property: Modified on
10844    #[serde(skip_serializing_if = "Option::is_none")]
10845    pub modified_at: Option<Vec<String>>,
10846    ///Property: Name
10847    #[serde(default)]
10848    pub name: Vec<String>,
10849    ///Property: Notes
10850    #[serde(skip_serializing_if = "Option::is_none")]
10851    pub notes: Option<Vec<String>>,
10852    ///Property: Owner
10853    #[serde(skip_serializing_if = "Option::is_none")]
10854    pub owner: Option<Vec<String>>,
10855    ///Property: Password
10856    #[serde(skip_serializing_if = "Option::is_none")]
10857    pub password: Option<Vec<String>>,
10858    ///Property: Phone
10859    #[serde(skip_serializing_if = "Option::is_none")]
10860    pub phone: Option<Vec<String>>,
10861    ///Property: Previous name
10862    #[serde(skip_serializing_if = "Option::is_none")]
10863    pub previous_name: Option<Vec<String>>,
10864    ///Property: Program
10865    #[serde(skip_serializing_if = "Option::is_none")]
10866    pub program: Option<Vec<String>>,
10867    ///Property: Program ID
10868    #[serde(skip_serializing_if = "Option::is_none")]
10869    pub program_id: Option<Vec<String>>,
10870    ///Property: Source document
10871    #[serde(skip_serializing_if = "Option::is_none")]
10872    pub proof: Option<Vec<String>>,
10873    ///Property: Publishing source
10874    #[serde(skip_serializing_if = "Option::is_none")]
10875    pub publisher: Option<Vec<String>>,
10876    ///Property: Publishing source URL
10877    #[serde(skip_serializing_if = "Option::is_none")]
10878    pub publisher_url: Option<Vec<String>>,
10879    ///Property: Retrieved on
10880    #[serde(skip_serializing_if = "Option::is_none")]
10881    pub retrieved_at: Option<Vec<String>>,
10882    ///Property: Service
10883    #[serde(skip_serializing_if = "Option::is_none")]
10884    pub service: Option<Vec<String>>,
10885    ///Property: Source link
10886    #[serde(skip_serializing_if = "Option::is_none")]
10887    pub source_url: Option<Vec<String>>,
10888    ///Property: Summary
10889    #[serde(skip_serializing_if = "Option::is_none")]
10890    pub summary: Option<Vec<String>>,
10891    ///Property: Topics
10892    #[serde(skip_serializing_if = "Option::is_none")]
10893    pub topics: Option<Vec<String>>,
10894    ///Property: Username
10895    #[serde(default)]
10896    pub username: Vec<String>,
10897    ///Property: Weak alias
10898    #[serde(skip_serializing_if = "Option::is_none")]
10899    pub weak_alias: Option<Vec<String>>,
10900    ///Property: Wikidata ID
10901    #[serde(skip_serializing_if = "Option::is_none")]
10902    pub wikidata_id: Option<Vec<String>>,
10903    ///Property: Wikipedia Article
10904    #[serde(skip_serializing_if = "Option::is_none")]
10905    pub wikipedia_url: Option<Vec<String>>,
10906}
10907impl UserAccount {
10908    /// Create a new entity with the given ID
10909    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
10910    pub fn new(id: impl Into<String>) -> Self {
10911        Self {
10912            id: id.into(),
10913            schema: "UserAccount".to_string(),
10914            address: None,
10915            address_entity: None,
10916            aleph_url: None,
10917            alias: None,
10918            country: None,
10919            created_at: None,
10920            description: None,
10921            email: None,
10922            index_text: None,
10923            ip_address: None,
10924            keywords: None,
10925            modified_at: None,
10926            name: Vec::new(),
10927            notes: None,
10928            owner: None,
10929            password: None,
10930            phone: None,
10931            previous_name: None,
10932            program: None,
10933            program_id: None,
10934            proof: None,
10935            publisher: None,
10936            publisher_url: None,
10937            retrieved_at: None,
10938            service: None,
10939            source_url: None,
10940            summary: None,
10941            topics: None,
10942            username: Vec::new(),
10943            weak_alias: None,
10944            wikidata_id: None,
10945            wikipedia_url: None,
10946        }
10947    }
10948    /// Get the schema name
10949    pub fn schema_name() -> &'static str {
10950        "UserAccount"
10951    }
10952}
10953///FTM Schema: Vehicle
10954#[derive(Debug, Clone, Serialize, Deserialize)]
10955#[cfg_attr(feature = "builder", derive(Builder))]
10956#[serde(rename_all = "camelCase")]
10957pub struct Vehicle {
10958    pub id: String,
10959    #[cfg_attr(feature = "builder", builder(default = "Vehicle".to_string()))]
10960    pub schema: String,
10961    ///Property: Address
10962    #[serde(skip_serializing_if = "Option::is_none")]
10963    pub address: Option<Vec<String>>,
10964    ///Property: Address
10965    #[serde(skip_serializing_if = "Option::is_none")]
10966    pub address_entity: Option<Vec<String>>,
10967    ///Property: Aleph URL
10968    #[serde(skip_serializing_if = "Option::is_none")]
10969    pub aleph_url: Option<Vec<String>>,
10970    ///Property: Alias
10971    #[serde(skip_serializing_if = "Option::is_none")]
10972    pub alias: Option<Vec<String>>,
10973    ///Property: Amount
10974    #[serde(
10975        skip_serializing_if = "Option::is_none",
10976        deserialize_with = "deserialize_opt_f64_vec",
10977        default
10978    )]
10979    pub amount: Option<Vec<f64>>,
10980    ///Property: Amount in EUR
10981    #[serde(
10982        skip_serializing_if = "Option::is_none",
10983        deserialize_with = "deserialize_opt_f64_vec",
10984        default
10985    )]
10986    pub amount_eur: Option<Vec<f64>>,
10987    ///Property: Amount in USD
10988    #[serde(
10989        skip_serializing_if = "Option::is_none",
10990        deserialize_with = "deserialize_opt_f64_vec",
10991        default
10992    )]
10993    pub amount_usd: Option<Vec<f64>>,
10994    ///Property: Build Date
10995    #[serde(skip_serializing_if = "Option::is_none")]
10996    pub build_date: Option<Vec<String>>,
10997    ///Property: Country
10998    #[serde(skip_serializing_if = "Option::is_none")]
10999    pub country: Option<Vec<String>>,
11000    ///Property: Created at
11001    #[serde(skip_serializing_if = "Option::is_none")]
11002    pub created_at: Option<Vec<String>>,
11003    ///Property: Currency
11004    #[serde(skip_serializing_if = "Option::is_none")]
11005    pub currency: Option<Vec<String>>,
11006    ///Property: De-registration Date
11007    #[serde(skip_serializing_if = "Option::is_none")]
11008    pub deregistration_date: Option<Vec<String>>,
11009    ///Property: Description
11010    #[serde(skip_serializing_if = "Option::is_none")]
11011    pub description: Option<Vec<String>>,
11012    ///Property: Index text
11013    #[serde(skip_serializing_if = "Option::is_none")]
11014    pub index_text: Option<Vec<String>>,
11015    ///Property: Keywords
11016    #[serde(skip_serializing_if = "Option::is_none")]
11017    pub keywords: Option<Vec<String>>,
11018    ///Property: Model
11019    #[serde(skip_serializing_if = "Option::is_none")]
11020    pub model: Option<Vec<String>>,
11021    ///Property: Modified on
11022    #[serde(skip_serializing_if = "Option::is_none")]
11023    pub modified_at: Option<Vec<String>>,
11024    ///Property: Name
11025    #[serde(default)]
11026    pub name: Vec<String>,
11027    ///Property: Notes
11028    #[serde(skip_serializing_if = "Option::is_none")]
11029    pub notes: Option<Vec<String>>,
11030    ///Property: Operator
11031    #[serde(skip_serializing_if = "Option::is_none")]
11032    pub operator: Option<Vec<String>>,
11033    ///Property: Owner
11034    #[serde(skip_serializing_if = "Option::is_none")]
11035    pub owner: Option<Vec<String>>,
11036    ///Property: Previous name
11037    #[serde(skip_serializing_if = "Option::is_none")]
11038    pub previous_name: Option<Vec<String>>,
11039    ///Property: Program
11040    #[serde(skip_serializing_if = "Option::is_none")]
11041    pub program: Option<Vec<String>>,
11042    ///Property: Program ID
11043    #[serde(skip_serializing_if = "Option::is_none")]
11044    pub program_id: Option<Vec<String>>,
11045    ///Property: Source document
11046    #[serde(skip_serializing_if = "Option::is_none")]
11047    pub proof: Option<Vec<String>>,
11048    ///Property: Publishing source
11049    #[serde(skip_serializing_if = "Option::is_none")]
11050    pub publisher: Option<Vec<String>>,
11051    ///Property: Publishing source URL
11052    #[serde(skip_serializing_if = "Option::is_none")]
11053    pub publisher_url: Option<Vec<String>>,
11054    ///Property: Registration Date
11055    #[serde(skip_serializing_if = "Option::is_none")]
11056    pub registration_date: Option<Vec<String>>,
11057    ///Property: Registration number
11058    #[serde(skip_serializing_if = "Option::is_none")]
11059    pub registration_number: Option<Vec<String>>,
11060    ///Property: Retrieved on
11061    #[serde(skip_serializing_if = "Option::is_none")]
11062    pub retrieved_at: Option<Vec<String>>,
11063    ///Property: Source link
11064    #[serde(skip_serializing_if = "Option::is_none")]
11065    pub source_url: Option<Vec<String>>,
11066    ///Property: Summary
11067    #[serde(skip_serializing_if = "Option::is_none")]
11068    pub summary: Option<Vec<String>>,
11069    ///Property: Topics
11070    #[serde(skip_serializing_if = "Option::is_none")]
11071    pub topics: Option<Vec<String>>,
11072    ///Property: Type
11073    #[serde(skip_serializing_if = "Option::is_none")]
11074    pub type_: Option<Vec<String>>,
11075    ///Property: Weak alias
11076    #[serde(skip_serializing_if = "Option::is_none")]
11077    pub weak_alias: Option<Vec<String>>,
11078    ///Property: Wikidata ID
11079    #[serde(skip_serializing_if = "Option::is_none")]
11080    pub wikidata_id: Option<Vec<String>>,
11081    ///Property: Wikipedia Article
11082    #[serde(skip_serializing_if = "Option::is_none")]
11083    pub wikipedia_url: Option<Vec<String>>,
11084}
11085impl Vehicle {
11086    /// Create a new entity with the given ID
11087    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
11088    pub fn new(id: impl Into<String>) -> Self {
11089        Self {
11090            id: id.into(),
11091            schema: "Vehicle".to_string(),
11092            address: None,
11093            address_entity: None,
11094            aleph_url: None,
11095            alias: None,
11096            amount: None,
11097            amount_eur: None,
11098            amount_usd: None,
11099            build_date: None,
11100            country: None,
11101            created_at: None,
11102            currency: None,
11103            deregistration_date: None,
11104            description: None,
11105            index_text: None,
11106            keywords: None,
11107            model: None,
11108            modified_at: None,
11109            name: Vec::new(),
11110            notes: None,
11111            operator: None,
11112            owner: None,
11113            previous_name: None,
11114            program: None,
11115            program_id: None,
11116            proof: None,
11117            publisher: None,
11118            publisher_url: None,
11119            registration_date: None,
11120            registration_number: None,
11121            retrieved_at: None,
11122            source_url: None,
11123            summary: None,
11124            topics: None,
11125            type_: None,
11126            weak_alias: None,
11127            wikidata_id: None,
11128            wikipedia_url: None,
11129        }
11130    }
11131    /// Get the schema name
11132    pub fn schema_name() -> &'static str {
11133        "Vehicle"
11134    }
11135}
11136///FTM Schema: Vessel
11137#[derive(Debug, Clone, Serialize, Deserialize)]
11138#[cfg_attr(feature = "builder", derive(Builder))]
11139#[serde(rename_all = "camelCase")]
11140pub struct Vessel {
11141    pub id: String,
11142    #[cfg_attr(feature = "builder", builder(default = "Vessel".to_string()))]
11143    pub schema: String,
11144    ///Property: Address
11145    #[serde(skip_serializing_if = "Option::is_none")]
11146    pub address: Option<Vec<String>>,
11147    ///Property: Address
11148    #[serde(skip_serializing_if = "Option::is_none")]
11149    pub address_entity: Option<Vec<String>>,
11150    ///Property: Aleph URL
11151    #[serde(skip_serializing_if = "Option::is_none")]
11152    pub aleph_url: Option<Vec<String>>,
11153    ///Property: Alias
11154    #[serde(skip_serializing_if = "Option::is_none")]
11155    pub alias: Option<Vec<String>>,
11156    ///Property: Amount
11157    #[serde(
11158        skip_serializing_if = "Option::is_none",
11159        deserialize_with = "deserialize_opt_f64_vec",
11160        default
11161    )]
11162    pub amount: Option<Vec<f64>>,
11163    ///Property: Amount in EUR
11164    #[serde(
11165        skip_serializing_if = "Option::is_none",
11166        deserialize_with = "deserialize_opt_f64_vec",
11167        default
11168    )]
11169    pub amount_eur: Option<Vec<f64>>,
11170    ///Property: Amount in USD
11171    #[serde(
11172        skip_serializing_if = "Option::is_none",
11173        deserialize_with = "deserialize_opt_f64_vec",
11174        default
11175    )]
11176    pub amount_usd: Option<Vec<f64>>,
11177    ///Property: Build Date
11178    #[serde(skip_serializing_if = "Option::is_none")]
11179    pub build_date: Option<Vec<String>>,
11180    ///Property: Call Sign
11181    #[serde(skip_serializing_if = "Option::is_none")]
11182    pub call_sign: Option<Vec<String>>,
11183    ///Property: Country
11184    #[serde(skip_serializing_if = "Option::is_none")]
11185    pub country: Option<Vec<String>>,
11186    ///Property: Created at
11187    #[serde(skip_serializing_if = "Option::is_none")]
11188    pub created_at: Option<Vec<String>>,
11189    ///Property: CRS Number
11190    #[serde(skip_serializing_if = "Option::is_none")]
11191    pub crs_number: Option<Vec<String>>,
11192    ///Property: Currency
11193    #[serde(skip_serializing_if = "Option::is_none")]
11194    pub currency: Option<Vec<String>>,
11195    ///Property: Deadweight Tonnage
11196    #[serde(
11197        skip_serializing_if = "Option::is_none",
11198        deserialize_with = "deserialize_opt_f64_vec",
11199        default
11200    )]
11201    pub deadweight_tonnage: Option<Vec<f64>>,
11202    ///Property: De-registration Date
11203    #[serde(skip_serializing_if = "Option::is_none")]
11204    pub deregistration_date: Option<Vec<String>>,
11205    ///Property: Description
11206    #[serde(skip_serializing_if = "Option::is_none")]
11207    pub description: Option<Vec<String>>,
11208    ///Property: Flag
11209    #[serde(skip_serializing_if = "Option::is_none")]
11210    pub flag: Option<Vec<String>>,
11211    ///Property: Gross Registered Tonnage
11212    #[serde(
11213        skip_serializing_if = "Option::is_none",
11214        deserialize_with = "deserialize_opt_f64_vec",
11215        default
11216    )]
11217    pub gross_registered_tonnage: Option<Vec<f64>>,
11218    ///Property: IMO Number
11219    #[serde(skip_serializing_if = "Option::is_none")]
11220    pub imo_number: Option<Vec<String>>,
11221    ///Property: Index text
11222    #[serde(skip_serializing_if = "Option::is_none")]
11223    pub index_text: Option<Vec<String>>,
11224    ///Property: Keywords
11225    #[serde(skip_serializing_if = "Option::is_none")]
11226    pub keywords: Option<Vec<String>>,
11227    ///Property: MMSI
11228    #[serde(skip_serializing_if = "Option::is_none")]
11229    pub mmsi: Option<Vec<String>>,
11230    ///Property: Model
11231    #[serde(skip_serializing_if = "Option::is_none")]
11232    pub model: Option<Vec<String>>,
11233    ///Property: Modified on
11234    #[serde(skip_serializing_if = "Option::is_none")]
11235    pub modified_at: Option<Vec<String>>,
11236    ///Property: Name
11237    #[serde(default)]
11238    pub name: Vec<String>,
11239    ///Property: Date of Name Change
11240    #[serde(skip_serializing_if = "Option::is_none")]
11241    pub name_change_date: Option<Vec<String>>,
11242    ///Property: Navigation Area
11243    #[serde(skip_serializing_if = "Option::is_none")]
11244    pub navigation_area: Option<Vec<String>>,
11245    ///Property: Notes
11246    #[serde(skip_serializing_if = "Option::is_none")]
11247    pub notes: Option<Vec<String>>,
11248    ///Property: Operator
11249    #[serde(skip_serializing_if = "Option::is_none")]
11250    pub operator: Option<Vec<String>>,
11251    ///Property: Owner
11252    #[serde(skip_serializing_if = "Option::is_none")]
11253    pub owner: Option<Vec<String>>,
11254    ///Property: Past Flags
11255    #[serde(skip_serializing_if = "Option::is_none")]
11256    pub past_flags: Option<Vec<String>>,
11257    ///Property: Past Types
11258    #[serde(skip_serializing_if = "Option::is_none")]
11259    pub past_types: Option<Vec<String>>,
11260    ///Property: Previous name
11261    #[serde(skip_serializing_if = "Option::is_none")]
11262    pub previous_name: Option<Vec<String>>,
11263    ///Property: Program
11264    #[serde(skip_serializing_if = "Option::is_none")]
11265    pub program: Option<Vec<String>>,
11266    ///Property: Program ID
11267    #[serde(skip_serializing_if = "Option::is_none")]
11268    pub program_id: Option<Vec<String>>,
11269    ///Property: Source document
11270    #[serde(skip_serializing_if = "Option::is_none")]
11271    pub proof: Option<Vec<String>>,
11272    ///Property: Publishing source
11273    #[serde(skip_serializing_if = "Option::is_none")]
11274    pub publisher: Option<Vec<String>>,
11275    ///Property: Publishing source URL
11276    #[serde(skip_serializing_if = "Option::is_none")]
11277    pub publisher_url: Option<Vec<String>>,
11278    ///Property: Registration Date
11279    #[serde(skip_serializing_if = "Option::is_none")]
11280    pub registration_date: Option<Vec<String>>,
11281    ///Property: Registration number
11282    #[serde(skip_serializing_if = "Option::is_none")]
11283    pub registration_number: Option<Vec<String>>,
11284    ///Property: Port of Registration
11285    #[serde(skip_serializing_if = "Option::is_none")]
11286    pub registration_port: Option<Vec<String>>,
11287    ///Property: Retrieved on
11288    #[serde(skip_serializing_if = "Option::is_none")]
11289    pub retrieved_at: Option<Vec<String>>,
11290    ///Property: Source link
11291    #[serde(skip_serializing_if = "Option::is_none")]
11292    pub source_url: Option<Vec<String>>,
11293    ///Property: Summary
11294    #[serde(skip_serializing_if = "Option::is_none")]
11295    pub summary: Option<Vec<String>>,
11296    ///Property: Tonnage
11297    #[serde(
11298        skip_serializing_if = "Option::is_none",
11299        deserialize_with = "deserialize_opt_f64_vec",
11300        default
11301    )]
11302    pub tonnage: Option<Vec<f64>>,
11303    ///Property: Topics
11304    #[serde(skip_serializing_if = "Option::is_none")]
11305    pub topics: Option<Vec<String>>,
11306    ///Property: Type
11307    #[serde(skip_serializing_if = "Option::is_none")]
11308    pub type_: Option<Vec<String>>,
11309    ///Property: Weak alias
11310    #[serde(skip_serializing_if = "Option::is_none")]
11311    pub weak_alias: Option<Vec<String>>,
11312    ///Property: Wikidata ID
11313    #[serde(skip_serializing_if = "Option::is_none")]
11314    pub wikidata_id: Option<Vec<String>>,
11315    ///Property: Wikipedia Article
11316    #[serde(skip_serializing_if = "Option::is_none")]
11317    pub wikipedia_url: Option<Vec<String>>,
11318}
11319impl Vessel {
11320    /// Create a new entity with the given ID
11321    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
11322    pub fn new(id: impl Into<String>) -> Self {
11323        Self {
11324            id: id.into(),
11325            schema: "Vessel".to_string(),
11326            address: None,
11327            address_entity: None,
11328            aleph_url: None,
11329            alias: None,
11330            amount: None,
11331            amount_eur: None,
11332            amount_usd: None,
11333            build_date: None,
11334            call_sign: None,
11335            country: None,
11336            created_at: None,
11337            crs_number: None,
11338            currency: None,
11339            deadweight_tonnage: None,
11340            deregistration_date: None,
11341            description: None,
11342            flag: None,
11343            gross_registered_tonnage: None,
11344            imo_number: None,
11345            index_text: None,
11346            keywords: None,
11347            mmsi: None,
11348            model: None,
11349            modified_at: None,
11350            name: Vec::new(),
11351            name_change_date: None,
11352            navigation_area: None,
11353            notes: None,
11354            operator: None,
11355            owner: None,
11356            past_flags: None,
11357            past_types: None,
11358            previous_name: None,
11359            program: None,
11360            program_id: None,
11361            proof: None,
11362            publisher: None,
11363            publisher_url: None,
11364            registration_date: None,
11365            registration_number: None,
11366            registration_port: None,
11367            retrieved_at: None,
11368            source_url: None,
11369            summary: None,
11370            tonnage: None,
11371            topics: None,
11372            type_: None,
11373            weak_alias: None,
11374            wikidata_id: None,
11375            wikipedia_url: None,
11376        }
11377    }
11378    /// Get the schema name
11379    pub fn schema_name() -> &'static str {
11380        "Vessel"
11381    }
11382}
11383///FTM Schema: Video
11384#[derive(Debug, Clone, Serialize, Deserialize)]
11385#[cfg_attr(feature = "builder", derive(Builder))]
11386#[serde(rename_all = "camelCase")]
11387pub struct Video {
11388    pub id: String,
11389    #[cfg_attr(feature = "builder", builder(default = "Video".to_string()))]
11390    pub schema: String,
11391    ///Property: Address
11392    #[serde(skip_serializing_if = "Option::is_none")]
11393    pub address: Option<Vec<String>>,
11394    ///Property: Address
11395    #[serde(skip_serializing_if = "Option::is_none")]
11396    pub address_entity: Option<Vec<String>>,
11397    ///Property: Aleph URL
11398    #[serde(skip_serializing_if = "Option::is_none")]
11399    pub aleph_url: Option<Vec<String>>,
11400    ///Property: Alias
11401    #[serde(skip_serializing_if = "Option::is_none")]
11402    pub alias: Option<Vec<String>>,
11403    ///Property: Ancestors
11404    #[serde(skip_serializing_if = "Option::is_none")]
11405    pub ancestors: Option<Vec<String>>,
11406    ///Property: Author
11407    #[serde(skip_serializing_if = "Option::is_none")]
11408    pub author: Option<Vec<String>>,
11409    ///Property: Authored on
11410    #[serde(skip_serializing_if = "Option::is_none")]
11411    pub authored_at: Option<Vec<String>>,
11412    ///Property: Text
11413    #[serde(skip_serializing_if = "Option::is_none")]
11414    pub body_text: Option<Vec<String>>,
11415    ///Property: Detected companies
11416    #[serde(skip_serializing_if = "Option::is_none")]
11417    pub companies_mentioned: Option<Vec<String>>,
11418    ///Property: Checksum
11419    #[serde(skip_serializing_if = "Option::is_none")]
11420    pub content_hash: Option<Vec<String>>,
11421    ///Property: Country
11422    #[serde(skip_serializing_if = "Option::is_none")]
11423    pub country: Option<Vec<String>>,
11424    ///Property: Crawler
11425    #[serde(skip_serializing_if = "Option::is_none")]
11426    pub crawler: Option<Vec<String>>,
11427    ///Property: Created at
11428    #[serde(skip_serializing_if = "Option::is_none")]
11429    pub created_at: Option<Vec<String>>,
11430    ///Property: Date
11431    #[serde(skip_serializing_if = "Option::is_none")]
11432    pub date: Option<Vec<String>>,
11433    ///Property: Description
11434    #[serde(skip_serializing_if = "Option::is_none")]
11435    pub description: Option<Vec<String>>,
11436    ///Property: Detected country
11437    #[serde(skip_serializing_if = "Option::is_none")]
11438    pub detected_country: Option<Vec<String>>,
11439    ///Property: Detected language
11440    #[serde(skip_serializing_if = "Option::is_none")]
11441    pub detected_language: Option<Vec<String>>,
11442    ///Property: Duration
11443    #[serde(
11444        skip_serializing_if = "Option::is_none",
11445        deserialize_with = "deserialize_opt_f64_vec",
11446        default
11447    )]
11448    pub duration: Option<Vec<f64>>,
11449    ///Property: Detected e-mail addresses
11450    #[serde(skip_serializing_if = "Option::is_none")]
11451    pub email_mentioned: Option<Vec<String>>,
11452    ///Property: File encoding
11453    #[serde(skip_serializing_if = "Option::is_none")]
11454    pub encoding: Option<Vec<String>>,
11455    ///Property: File extension
11456    #[serde(skip_serializing_if = "Option::is_none")]
11457    pub extension: Option<Vec<String>>,
11458    ///Property: File name
11459    #[serde(default)]
11460    pub file_name: Vec<String>,
11461    ///Property: File size
11462    #[serde(
11463        skip_serializing_if = "Option::is_none",
11464        deserialize_with = "deserialize_opt_f64_vec",
11465        default
11466    )]
11467    pub file_size: Option<Vec<f64>>,
11468    ///Property: Generator
11469    #[serde(skip_serializing_if = "Option::is_none")]
11470    pub generator: Option<Vec<String>>,
11471    ///Property: Detected IBANs
11472    #[serde(skip_serializing_if = "Option::is_none")]
11473    pub iban_mentioned: Option<Vec<String>>,
11474    ///Property: Index text
11475    #[serde(skip_serializing_if = "Option::is_none")]
11476    pub index_text: Option<Vec<String>>,
11477    ///Property: Detected IP addresses
11478    #[serde(skip_serializing_if = "Option::is_none")]
11479    pub ip_mentioned: Option<Vec<String>>,
11480    ///Property: Keywords
11481    #[serde(skip_serializing_if = "Option::is_none")]
11482    pub keywords: Option<Vec<String>>,
11483    ///Property: Language
11484    #[serde(skip_serializing_if = "Option::is_none")]
11485    pub language: Option<Vec<String>>,
11486    ///Property: Detected locations
11487    #[serde(skip_serializing_if = "Option::is_none")]
11488    pub location_mentioned: Option<Vec<String>>,
11489    ///Property: Message ID
11490    #[serde(skip_serializing_if = "Option::is_none")]
11491    pub message_id: Option<Vec<String>>,
11492    ///Property: MIME type
11493    #[serde(skip_serializing_if = "Option::is_none")]
11494    pub mime_type: Option<Vec<String>>,
11495    ///Property: Modified on
11496    #[serde(skip_serializing_if = "Option::is_none")]
11497    pub modified_at: Option<Vec<String>>,
11498    ///Property: Name
11499    #[serde(default)]
11500    pub name: Vec<String>,
11501    ///Property: Detected names
11502    #[serde(skip_serializing_if = "Option::is_none")]
11503    pub names_mentioned: Option<Vec<String>>,
11504    ///Property: Notes
11505    #[serde(skip_serializing_if = "Option::is_none")]
11506    pub notes: Option<Vec<String>>,
11507    ///Property: Folder
11508    #[serde(skip_serializing_if = "Option::is_none")]
11509    pub parent: Option<Vec<String>>,
11510    ///Property: Detected people
11511    #[serde(skip_serializing_if = "Option::is_none")]
11512    pub people_mentioned: Option<Vec<String>>,
11513    ///Property: Detected phones
11514    #[serde(skip_serializing_if = "Option::is_none")]
11515    pub phone_mentioned: Option<Vec<String>>,
11516    ///Property: Previous name
11517    #[serde(skip_serializing_if = "Option::is_none")]
11518    pub previous_name: Option<Vec<String>>,
11519    ///Property: Processed at
11520    #[serde(skip_serializing_if = "Option::is_none")]
11521    pub processed_at: Option<Vec<String>>,
11522    ///Property: Processing agent
11523    #[serde(skip_serializing_if = "Option::is_none")]
11524    pub processing_agent: Option<Vec<String>>,
11525    ///Property: Processing error
11526    #[serde(skip_serializing_if = "Option::is_none")]
11527    pub processing_error: Option<Vec<String>>,
11528    ///Property: Processing status
11529    #[serde(skip_serializing_if = "Option::is_none")]
11530    pub processing_status: Option<Vec<String>>,
11531    ///Property: Program
11532    #[serde(skip_serializing_if = "Option::is_none")]
11533    pub program: Option<Vec<String>>,
11534    ///Property: Program ID
11535    #[serde(skip_serializing_if = "Option::is_none")]
11536    pub program_id: Option<Vec<String>>,
11537    ///Property: Source document
11538    #[serde(skip_serializing_if = "Option::is_none")]
11539    pub proof: Option<Vec<String>>,
11540    ///Property: Published on
11541    #[serde(skip_serializing_if = "Option::is_none")]
11542    pub published_at: Option<Vec<String>>,
11543    ///Property: Publishing source
11544    #[serde(skip_serializing_if = "Option::is_none")]
11545    pub publisher: Option<Vec<String>>,
11546    ///Property: Publishing source URL
11547    #[serde(skip_serializing_if = "Option::is_none")]
11548    pub publisher_url: Option<Vec<String>>,
11549    ///Property: Retrieved on
11550    #[serde(skip_serializing_if = "Option::is_none")]
11551    pub retrieved_at: Option<Vec<String>>,
11552    ///Property: Source link
11553    #[serde(skip_serializing_if = "Option::is_none")]
11554    pub source_url: Option<Vec<String>>,
11555    ///Property: Summary
11556    #[serde(skip_serializing_if = "Option::is_none")]
11557    pub summary: Option<Vec<String>>,
11558    ///Property: Title
11559    #[serde(skip_serializing_if = "Option::is_none")]
11560    pub title: Option<Vec<String>>,
11561    ///Property: Topics
11562    #[serde(skip_serializing_if = "Option::is_none")]
11563    pub topics: Option<Vec<String>>,
11564    ///Property: The language of the translated text
11565    #[serde(skip_serializing_if = "Option::is_none")]
11566    pub translated_language: Option<Vec<String>>,
11567    ///Property: Translated version of the body text
11568    #[serde(skip_serializing_if = "Option::is_none")]
11569    pub translated_text: Option<Vec<String>>,
11570    ///Property: Weak alias
11571    #[serde(skip_serializing_if = "Option::is_none")]
11572    pub weak_alias: Option<Vec<String>>,
11573    ///Property: Wikidata ID
11574    #[serde(skip_serializing_if = "Option::is_none")]
11575    pub wikidata_id: Option<Vec<String>>,
11576    ///Property: Wikipedia Article
11577    #[serde(skip_serializing_if = "Option::is_none")]
11578    pub wikipedia_url: Option<Vec<String>>,
11579}
11580impl Video {
11581    /// Create a new entity with the given ID
11582    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
11583    pub fn new(id: impl Into<String>) -> Self {
11584        Self {
11585            id: id.into(),
11586            schema: "Video".to_string(),
11587            address: None,
11588            address_entity: None,
11589            aleph_url: None,
11590            alias: None,
11591            ancestors: None,
11592            author: None,
11593            authored_at: None,
11594            body_text: None,
11595            companies_mentioned: None,
11596            content_hash: None,
11597            country: None,
11598            crawler: None,
11599            created_at: None,
11600            date: None,
11601            description: None,
11602            detected_country: None,
11603            detected_language: None,
11604            duration: None,
11605            email_mentioned: None,
11606            encoding: None,
11607            extension: None,
11608            file_name: Vec::new(),
11609            file_size: None,
11610            generator: None,
11611            iban_mentioned: None,
11612            index_text: None,
11613            ip_mentioned: None,
11614            keywords: None,
11615            language: None,
11616            location_mentioned: None,
11617            message_id: None,
11618            mime_type: None,
11619            modified_at: None,
11620            name: Vec::new(),
11621            names_mentioned: None,
11622            notes: None,
11623            parent: None,
11624            people_mentioned: None,
11625            phone_mentioned: None,
11626            previous_name: None,
11627            processed_at: None,
11628            processing_agent: None,
11629            processing_error: None,
11630            processing_status: None,
11631            program: None,
11632            program_id: None,
11633            proof: None,
11634            published_at: None,
11635            publisher: None,
11636            publisher_url: None,
11637            retrieved_at: None,
11638            source_url: None,
11639            summary: None,
11640            title: None,
11641            topics: None,
11642            translated_language: None,
11643            translated_text: None,
11644            weak_alias: None,
11645            wikidata_id: None,
11646            wikipedia_url: None,
11647        }
11648    }
11649    /// Get the schema name
11650    pub fn schema_name() -> &'static str {
11651        "Video"
11652    }
11653}
11654///FTM Schema: Workbook
11655#[derive(Debug, Clone, Serialize, Deserialize)]
11656#[cfg_attr(feature = "builder", derive(Builder))]
11657#[serde(rename_all = "camelCase")]
11658pub struct Workbook {
11659    pub id: String,
11660    #[cfg_attr(feature = "builder", builder(default = "Workbook".to_string()))]
11661    pub schema: String,
11662    ///Property: Address
11663    #[serde(skip_serializing_if = "Option::is_none")]
11664    pub address: Option<Vec<String>>,
11665    ///Property: Address
11666    #[serde(skip_serializing_if = "Option::is_none")]
11667    pub address_entity: Option<Vec<String>>,
11668    ///Property: Aleph URL
11669    #[serde(skip_serializing_if = "Option::is_none")]
11670    pub aleph_url: Option<Vec<String>>,
11671    ///Property: Alias
11672    #[serde(skip_serializing_if = "Option::is_none")]
11673    pub alias: Option<Vec<String>>,
11674    ///Property: Ancestors
11675    #[serde(skip_serializing_if = "Option::is_none")]
11676    pub ancestors: Option<Vec<String>>,
11677    ///Property: Author
11678    #[serde(skip_serializing_if = "Option::is_none")]
11679    pub author: Option<Vec<String>>,
11680    ///Property: Authored on
11681    #[serde(skip_serializing_if = "Option::is_none")]
11682    pub authored_at: Option<Vec<String>>,
11683    ///Property: Text
11684    #[serde(skip_serializing_if = "Option::is_none")]
11685    pub body_text: Option<Vec<String>>,
11686    ///Property: Detected companies
11687    #[serde(skip_serializing_if = "Option::is_none")]
11688    pub companies_mentioned: Option<Vec<String>>,
11689    ///Property: Checksum
11690    #[serde(skip_serializing_if = "Option::is_none")]
11691    pub content_hash: Option<Vec<String>>,
11692    ///Property: Country
11693    #[serde(skip_serializing_if = "Option::is_none")]
11694    pub country: Option<Vec<String>>,
11695    ///Property: Crawler
11696    #[serde(skip_serializing_if = "Option::is_none")]
11697    pub crawler: Option<Vec<String>>,
11698    ///Property: Created at
11699    #[serde(skip_serializing_if = "Option::is_none")]
11700    pub created_at: Option<Vec<String>>,
11701    ///Property: Date
11702    #[serde(skip_serializing_if = "Option::is_none")]
11703    pub date: Option<Vec<String>>,
11704    ///Property: Description
11705    #[serde(skip_serializing_if = "Option::is_none")]
11706    pub description: Option<Vec<String>>,
11707    ///Property: Detected country
11708    #[serde(skip_serializing_if = "Option::is_none")]
11709    pub detected_country: Option<Vec<String>>,
11710    ///Property: Detected language
11711    #[serde(skip_serializing_if = "Option::is_none")]
11712    pub detected_language: Option<Vec<String>>,
11713    ///Property: Detected e-mail addresses
11714    #[serde(skip_serializing_if = "Option::is_none")]
11715    pub email_mentioned: Option<Vec<String>>,
11716    ///Property: File encoding
11717    #[serde(skip_serializing_if = "Option::is_none")]
11718    pub encoding: Option<Vec<String>>,
11719    ///Property: File extension
11720    #[serde(skip_serializing_if = "Option::is_none")]
11721    pub extension: Option<Vec<String>>,
11722    ///Property: File name
11723    #[serde(default)]
11724    pub file_name: Vec<String>,
11725    ///Property: File size
11726    #[serde(
11727        skip_serializing_if = "Option::is_none",
11728        deserialize_with = "deserialize_opt_f64_vec",
11729        default
11730    )]
11731    pub file_size: Option<Vec<f64>>,
11732    ///Property: Generator
11733    #[serde(skip_serializing_if = "Option::is_none")]
11734    pub generator: Option<Vec<String>>,
11735    ///Property: Detected IBANs
11736    #[serde(skip_serializing_if = "Option::is_none")]
11737    pub iban_mentioned: Option<Vec<String>>,
11738    ///Property: Index text
11739    #[serde(skip_serializing_if = "Option::is_none")]
11740    pub index_text: Option<Vec<String>>,
11741    ///Property: Detected IP addresses
11742    #[serde(skip_serializing_if = "Option::is_none")]
11743    pub ip_mentioned: Option<Vec<String>>,
11744    ///Property: Keywords
11745    #[serde(skip_serializing_if = "Option::is_none")]
11746    pub keywords: Option<Vec<String>>,
11747    ///Property: Language
11748    #[serde(skip_serializing_if = "Option::is_none")]
11749    pub language: Option<Vec<String>>,
11750    ///Property: Detected locations
11751    #[serde(skip_serializing_if = "Option::is_none")]
11752    pub location_mentioned: Option<Vec<String>>,
11753    ///Property: Message ID
11754    #[serde(skip_serializing_if = "Option::is_none")]
11755    pub message_id: Option<Vec<String>>,
11756    ///Property: MIME type
11757    #[serde(skip_serializing_if = "Option::is_none")]
11758    pub mime_type: Option<Vec<String>>,
11759    ///Property: Modified on
11760    #[serde(skip_serializing_if = "Option::is_none")]
11761    pub modified_at: Option<Vec<String>>,
11762    ///Property: Name
11763    #[serde(default)]
11764    pub name: Vec<String>,
11765    ///Property: Detected names
11766    #[serde(skip_serializing_if = "Option::is_none")]
11767    pub names_mentioned: Option<Vec<String>>,
11768    ///Property: Notes
11769    #[serde(skip_serializing_if = "Option::is_none")]
11770    pub notes: Option<Vec<String>>,
11771    ///Property: Folder
11772    #[serde(skip_serializing_if = "Option::is_none")]
11773    pub parent: Option<Vec<String>>,
11774    ///Property: Detected people
11775    #[serde(skip_serializing_if = "Option::is_none")]
11776    pub people_mentioned: Option<Vec<String>>,
11777    ///Property: Detected phones
11778    #[serde(skip_serializing_if = "Option::is_none")]
11779    pub phone_mentioned: Option<Vec<String>>,
11780    ///Property: Previous name
11781    #[serde(skip_serializing_if = "Option::is_none")]
11782    pub previous_name: Option<Vec<String>>,
11783    ///Property: Processed at
11784    #[serde(skip_serializing_if = "Option::is_none")]
11785    pub processed_at: Option<Vec<String>>,
11786    ///Property: Processing agent
11787    #[serde(skip_serializing_if = "Option::is_none")]
11788    pub processing_agent: Option<Vec<String>>,
11789    ///Property: Processing error
11790    #[serde(skip_serializing_if = "Option::is_none")]
11791    pub processing_error: Option<Vec<String>>,
11792    ///Property: Processing status
11793    #[serde(skip_serializing_if = "Option::is_none")]
11794    pub processing_status: Option<Vec<String>>,
11795    ///Property: Program
11796    #[serde(skip_serializing_if = "Option::is_none")]
11797    pub program: Option<Vec<String>>,
11798    ///Property: Program ID
11799    #[serde(skip_serializing_if = "Option::is_none")]
11800    pub program_id: Option<Vec<String>>,
11801    ///Property: Source document
11802    #[serde(skip_serializing_if = "Option::is_none")]
11803    pub proof: Option<Vec<String>>,
11804    ///Property: Published on
11805    #[serde(skip_serializing_if = "Option::is_none")]
11806    pub published_at: Option<Vec<String>>,
11807    ///Property: Publishing source
11808    #[serde(skip_serializing_if = "Option::is_none")]
11809    pub publisher: Option<Vec<String>>,
11810    ///Property: Publishing source URL
11811    #[serde(skip_serializing_if = "Option::is_none")]
11812    pub publisher_url: Option<Vec<String>>,
11813    ///Property: Retrieved on
11814    #[serde(skip_serializing_if = "Option::is_none")]
11815    pub retrieved_at: Option<Vec<String>>,
11816    ///Property: Source link
11817    #[serde(skip_serializing_if = "Option::is_none")]
11818    pub source_url: Option<Vec<String>>,
11819    ///Property: Summary
11820    #[serde(skip_serializing_if = "Option::is_none")]
11821    pub summary: Option<Vec<String>>,
11822    ///Property: Title
11823    #[serde(skip_serializing_if = "Option::is_none")]
11824    pub title: Option<Vec<String>>,
11825    ///Property: Topics
11826    #[serde(skip_serializing_if = "Option::is_none")]
11827    pub topics: Option<Vec<String>>,
11828    ///Property: The language of the translated text
11829    #[serde(skip_serializing_if = "Option::is_none")]
11830    pub translated_language: Option<Vec<String>>,
11831    ///Property: Translated version of the body text
11832    #[serde(skip_serializing_if = "Option::is_none")]
11833    pub translated_text: Option<Vec<String>>,
11834    ///Property: Weak alias
11835    #[serde(skip_serializing_if = "Option::is_none")]
11836    pub weak_alias: Option<Vec<String>>,
11837    ///Property: Wikidata ID
11838    #[serde(skip_serializing_if = "Option::is_none")]
11839    pub wikidata_id: Option<Vec<String>>,
11840    ///Property: Wikipedia Article
11841    #[serde(skip_serializing_if = "Option::is_none")]
11842    pub wikipedia_url: Option<Vec<String>>,
11843}
11844impl Workbook {
11845    /// Create a new entity with the given ID
11846    #[deprecated(note = "Use the builder() method instead to ensure required fields are set")]
11847    pub fn new(id: impl Into<String>) -> Self {
11848        Self {
11849            id: id.into(),
11850            schema: "Workbook".to_string(),
11851            address: None,
11852            address_entity: None,
11853            aleph_url: None,
11854            alias: None,
11855            ancestors: None,
11856            author: None,
11857            authored_at: None,
11858            body_text: None,
11859            companies_mentioned: None,
11860            content_hash: None,
11861            country: None,
11862            crawler: None,
11863            created_at: None,
11864            date: None,
11865            description: None,
11866            detected_country: None,
11867            detected_language: None,
11868            email_mentioned: None,
11869            encoding: None,
11870            extension: None,
11871            file_name: Vec::new(),
11872            file_size: None,
11873            generator: None,
11874            iban_mentioned: None,
11875            index_text: None,
11876            ip_mentioned: None,
11877            keywords: None,
11878            language: None,
11879            location_mentioned: None,
11880            message_id: None,
11881            mime_type: None,
11882            modified_at: None,
11883            name: Vec::new(),
11884            names_mentioned: None,
11885            notes: None,
11886            parent: None,
11887            people_mentioned: None,
11888            phone_mentioned: None,
11889            previous_name: None,
11890            processed_at: None,
11891            processing_agent: None,
11892            processing_error: None,
11893            processing_status: None,
11894            program: None,
11895            program_id: None,
11896            proof: None,
11897            published_at: None,
11898            publisher: None,
11899            publisher_url: None,
11900            retrieved_at: None,
11901            source_url: None,
11902            summary: None,
11903            title: None,
11904            topics: None,
11905            translated_language: None,
11906            translated_text: None,
11907            weak_alias: None,
11908            wikidata_id: None,
11909            wikipedia_url: None,
11910        }
11911    }
11912    /// Get the schema name
11913    pub fn schema_name() -> &'static str {
11914        "Workbook"
11915    }
11916}
ftm_types/generated/entities.rs

ftm_types/generated/
entities.rs
