haste_fhir_generated_ops/
generated.rs

1#![allow(non_snake_case)]
2use haste_fhir_model::r4::generated::resources::*;
3use haste_fhir_model::r4::generated::types::*;
4use haste_fhir_operation_error::*;
5use haste_fhir_ops::derive::{FromParameters, ToParameters};
6pub mod HasteHealthDeleteRefreshToken {
7    use super::*;
8    pub const CODE: &str = "delete-refresh-token";
9    #[derive(Debug, FromParameters, ToParameters)]
10    pub struct Input {
11        pub client_id: FHIRId,
12        pub user_agent: Option<FHIRString>,
13    }
14    impl From<Input> for Resource {
15        fn from(value: Input) -> Self {
16            let parameters: Vec<ParametersParameter> = value.into();
17            Resource::Parameters(Parameters {
18                parameter: Some(parameters),
19                ..Default::default()
20            })
21        }
22    }
23    #[derive(Debug, FromParameters)]
24    pub struct Output {
25        #[parameter_rename = "return"]
26        pub return_: OperationOutcome,
27    }
28    impl From<Output> for Resource {
29        fn from(value: Output) -> Self {
30            Resource::OperationOutcome(value.return_)
31        }
32    }
33}
34pub mod HasteHealthListRefreshTokens {
35    use super::*;
36    pub const CODE: &str = "refresh-tokens";
37    #[derive(Debug, FromParameters, ToParameters)]
38    pub struct Input {}
39    impl From<Input> for Resource {
40        fn from(value: Input) -> Self {
41            let parameters: Vec<ParametersParameter> = value.into();
42            Resource::Parameters(Parameters {
43                parameter: Some(parameters),
44                ..Default::default()
45            })
46        }
47    }
48    #[derive(Debug, FromParameters, ToParameters)]
49    pub struct OutputRefreshTokens {
50        pub client_id: FHIRId,
51        pub user_agent: FHIRString,
52        pub created_at: FHIRDateTime,
53    }
54    impl From<OutputRefreshTokens> for Resource {
55        fn from(value: OutputRefreshTokens) -> Self {
56            let parameters: Vec<ParametersParameter> = value.into();
57            Resource::Parameters(Parameters {
58                parameter: Some(parameters),
59                ..Default::default()
60            })
61        }
62    }
63    #[derive(Debug, FromParameters, ToParameters)]
64    pub struct Output {
65        #[parameter_rename = "refresh-tokens"]
66        #[parameter_nested]
67        pub refresh_tokens: Option<Vec<OutputRefreshTokens>>,
68    }
69    impl From<Output> for Resource {
70        fn from(value: Output) -> Self {
71            let parameters: Vec<ParametersParameter> = value.into();
72            Resource::Parameters(Parameters {
73                parameter: Some(parameters),
74                ..Default::default()
75            })
76        }
77    }
78}
79pub mod TenantEndpointInformation {
80    use super::*;
81    pub const CODE: &str = "endpoints";
82    #[derive(Debug, FromParameters, ToParameters)]
83    pub struct Input {}
84    impl From<Input> for Resource {
85        fn from(value: Input) -> Self {
86            let parameters: Vec<ParametersParameter> = value.into();
87            Resource::Parameters(Parameters {
88                parameter: Some(parameters),
89                ..Default::default()
90            })
91        }
92    }
93    #[derive(Debug, FromParameters, ToParameters)]
94    pub struct Output {
95        #[parameter_rename = "fhir-r4-base-url"]
96        pub fhir_r4_base_url: FHIRUri,
97        #[parameter_rename = "fhir-r4-capabilities-url"]
98        pub fhir_r4_capabilities_url: FHIRUri,
99        #[parameter_rename = "oidc-discovery-url"]
100        pub oidc_discovery_url: FHIRUri,
101        #[parameter_rename = "oidc-token-endpoint"]
102        pub oidc_token_endpoint: FHIRUri,
103        #[parameter_rename = "oidc-authorize-endpoint"]
104        pub oidc_authorize_endpoint: FHIRUri,
105        #[parameter_rename = "oidc-jwks-endpoint"]
106        pub oidc_jwks_endpoint: FHIRUri,
107        #[parameter_rename = "mcp-endpoint"]
108        pub mcp_endpoint: FHIRUri,
109    }
110    impl From<Output> for Resource {
111        fn from(value: Output) -> Self {
112            let parameters: Vec<ParametersParameter> = value.into();
113            Resource::Parameters(Parameters {
114                parameter: Some(parameters),
115                ..Default::default()
116            })
117        }
118    }
119}
120pub mod HasteHealthIdpRegistrationInfo {
121    use super::*;
122    pub const CODE: &str = "registration-info";
123    #[derive(Debug, FromParameters, ToParameters)]
124    pub struct Input {}
125    impl From<Input> for Resource {
126        fn from(value: Input) -> Self {
127            let parameters: Vec<ParametersParameter> = value.into();
128            Resource::Parameters(Parameters {
129                parameter: Some(parameters),
130                ..Default::default()
131            })
132        }
133    }
134    #[derive(Debug, FromParameters, ToParameters)]
135    pub struct OutputInformation {
136        pub name: FHIRString,
137        pub value: FHIRString,
138    }
139    impl From<OutputInformation> for Resource {
140        fn from(value: OutputInformation) -> Self {
141            let parameters: Vec<ParametersParameter> = value.into();
142            Resource::Parameters(Parameters {
143                parameter: Some(parameters),
144                ..Default::default()
145            })
146        }
147    }
148    #[derive(Debug, FromParameters, ToParameters)]
149    pub struct Output {
150        #[parameter_nested]
151        pub information: Option<Vec<OutputInformation>>,
152    }
153    impl From<Output> for Resource {
154        fn from(value: Output) -> Self {
155            let parameters: Vec<ParametersParameter> = value.into();
156            Resource::Parameters(Parameters {
157                parameter: Some(parameters),
158                ..Default::default()
159            })
160        }
161    }
162}
163pub mod HasteHealthDeleteScope {
164    use super::*;
165    pub const CODE: &str = "delete-scope";
166    #[derive(Debug, FromParameters, ToParameters)]
167    pub struct Input {
168        pub client_id: FHIRId,
169    }
170    impl From<Input> for Resource {
171        fn from(value: Input) -> Self {
172            let parameters: Vec<ParametersParameter> = value.into();
173            Resource::Parameters(Parameters {
174                parameter: Some(parameters),
175                ..Default::default()
176            })
177        }
178    }
179    #[derive(Debug, FromParameters)]
180    pub struct Output {
181        #[parameter_rename = "return"]
182        pub return_: OperationOutcome,
183    }
184    impl From<Output> for Resource {
185        fn from(value: Output) -> Self {
186            Resource::OperationOutcome(value.return_)
187        }
188    }
189}
190pub mod HasteHealthListScopes {
191    use super::*;
192    pub const CODE: &str = "scopes";
193    #[derive(Debug, FromParameters, ToParameters)]
194    pub struct Input {}
195    impl From<Input> for Resource {
196        fn from(value: Input) -> Self {
197            let parameters: Vec<ParametersParameter> = value.into();
198            Resource::Parameters(Parameters {
199                parameter: Some(parameters),
200                ..Default::default()
201            })
202        }
203    }
204    #[derive(Debug, FromParameters, ToParameters)]
205    pub struct OutputScopes {
206        pub client_id: FHIRId,
207        pub scopes: FHIRString,
208        pub created_at: FHIRDateTime,
209    }
210    impl From<OutputScopes> for Resource {
211        fn from(value: OutputScopes) -> Self {
212            let parameters: Vec<ParametersParameter> = value.into();
213            Resource::Parameters(Parameters {
214                parameter: Some(parameters),
215                ..Default::default()
216            })
217        }
218    }
219    #[derive(Debug, FromParameters, ToParameters)]
220    pub struct Output {
221        #[parameter_nested]
222        pub scopes: Option<Vec<OutputScopes>>,
223    }
224    impl From<Output> for Resource {
225        fn from(value: Output) -> Self {
226            let parameters: Vec<ParametersParameter> = value.into();
227            Resource::Parameters(Parameters {
228                parameter: Some(parameters),
229                ..Default::default()
230            })
231        }
232    }
233}
234pub mod ProjectInformation {
235    use super::*;
236    pub const CODE: &str = "current-project";
237    #[derive(Debug, FromParameters, ToParameters)]
238    pub struct Input {}
239    impl From<Input> for Resource {
240        fn from(value: Input) -> Self {
241            let parameters: Vec<ParametersParameter> = value.into();
242            Resource::Parameters(Parameters {
243                parameter: Some(parameters),
244                ..Default::default()
245            })
246        }
247    }
248    #[derive(Debug, FromParameters, ToParameters)]
249    pub struct Output {
250        pub project: Project,
251    }
252    impl From<Output> for Resource {
253        fn from(value: Output) -> Self {
254            let parameters: Vec<ParametersParameter> = value.into();
255            Resource::Parameters(Parameters {
256                parameter: Some(parameters),
257                ..Default::default()
258            })
259        }
260    }
261}
262pub mod TenantInformation {
263    use super::*;
264    pub const CODE: &str = "current-tenant";
265    #[derive(Debug, FromParameters, ToParameters)]
266    pub struct Input {}
267    impl From<Input> for Resource {
268        fn from(value: Input) -> Self {
269            let parameters: Vec<ParametersParameter> = value.into();
270            Resource::Parameters(Parameters {
271                parameter: Some(parameters),
272                ..Default::default()
273            })
274        }
275    }
276    #[derive(Debug, FromParameters, ToParameters)]
277    pub struct Output {
278        pub id: FHIRString,
279        pub subscription: FHIRCode,
280    }
281    impl From<Output> for Resource {
282        fn from(value: Output) -> Self {
283            let parameters: Vec<ParametersParameter> = value.into();
284            Resource::Parameters(Parameters {
285                parameter: Some(parameters),
286                ..Default::default()
287            })
288        }
289    }
290}
291pub mod ActivityDefinitionApply {
292    use super::*;
293    pub const CODE: &str = "apply";
294    #[derive(Debug, FromParameters, ToParameters)]
295    pub struct Input {
296        pub activityDefinition: Option<ActivityDefinition>,
297        pub subject: Vec<FHIRString>,
298        pub encounter: Option<FHIRString>,
299        pub practitioner: Option<FHIRString>,
300        pub organization: Option<FHIRString>,
301        pub userType: Option<CodeableConcept>,
302        pub userLanguage: Option<CodeableConcept>,
303        pub userTaskContext: Option<CodeableConcept>,
304        pub setting: Option<CodeableConcept>,
305        pub settingContext: Option<CodeableConcept>,
306    }
307    impl From<Input> for Resource {
308        fn from(value: Input) -> Self {
309            let parameters: Vec<ParametersParameter> = value.into();
310            Resource::Parameters(Parameters {
311                parameter: Some(parameters),
312                ..Default::default()
313            })
314        }
315    }
316    #[derive(Debug, FromParameters)]
317    pub struct Output {
318        #[parameter_rename = "return"]
319        pub return_: Resource,
320    }
321    impl From<Output> for Resource {
322        fn from(value: Output) -> Self {
323            value.return_
324        }
325    }
326}
327pub mod ActivityDefinitionDataRequirements {
328    use super::*;
329    pub const CODE: &str = "data-requirements";
330    #[derive(Debug, FromParameters, ToParameters)]
331    pub struct Input {}
332    impl From<Input> for Resource {
333        fn from(value: Input) -> Self {
334            let parameters: Vec<ParametersParameter> = value.into();
335            Resource::Parameters(Parameters {
336                parameter: Some(parameters),
337                ..Default::default()
338            })
339        }
340    }
341    #[derive(Debug, FromParameters)]
342    pub struct Output {
343        #[parameter_rename = "return"]
344        pub return_: Library,
345    }
346    impl From<Output> for Resource {
347        fn from(value: Output) -> Self {
348            Resource::Library(value.return_)
349        }
350    }
351}
352pub mod CapabilityStatementConforms {
353    use super::*;
354    pub const CODE: &str = "conforms";
355    #[derive(Debug, FromParameters, ToParameters)]
356    pub struct Input {
357        pub left: Option<FHIRString>,
358        pub right: Option<FHIRString>,
359        pub mode: Option<FHIRCode>,
360    }
361    impl From<Input> for Resource {
362        fn from(value: Input) -> Self {
363            let parameters: Vec<ParametersParameter> = value.into();
364            Resource::Parameters(Parameters {
365                parameter: Some(parameters),
366                ..Default::default()
367            })
368        }
369    }
370    #[derive(Debug, FromParameters, ToParameters)]
371    pub struct Output {
372        pub issues: OperationOutcome,
373        pub union: Option<CapabilityStatement>,
374        pub intersection: Option<CapabilityStatement>,
375    }
376    impl From<Output> for Resource {
377        fn from(value: Output) -> Self {
378            let parameters: Vec<ParametersParameter> = value.into();
379            Resource::Parameters(Parameters {
380                parameter: Some(parameters),
381                ..Default::default()
382            })
383        }
384    }
385}
386pub mod CapabilityStatementImplements {
387    use super::*;
388    pub const CODE: &str = "implements";
389    #[derive(Debug, FromParameters, ToParameters)]
390    pub struct Input {
391        pub server: Option<FHIRString>,
392        pub client: Option<FHIRString>,
393        pub resource: Option<CapabilityStatement>,
394    }
395    impl From<Input> for Resource {
396        fn from(value: Input) -> Self {
397            let parameters: Vec<ParametersParameter> = value.into();
398            Resource::Parameters(Parameters {
399                parameter: Some(parameters),
400                ..Default::default()
401            })
402        }
403    }
404    #[derive(Debug, FromParameters)]
405    pub struct Output {
406        #[parameter_rename = "return"]
407        pub return_: OperationOutcome,
408    }
409    impl From<Output> for Resource {
410        fn from(value: Output) -> Self {
411            Resource::OperationOutcome(value.return_)
412        }
413    }
414}
415pub mod CapabilityStatementSubset {
416    use super::*;
417    pub const CODE: &str = "subset";
418    #[derive(Debug, FromParameters, ToParameters)]
419    pub struct Input {
420        pub server: Option<FHIRUri>,
421        pub resource: Vec<FHIRCode>,
422    }
423    impl From<Input> for Resource {
424        fn from(value: Input) -> Self {
425            let parameters: Vec<ParametersParameter> = value.into();
426            Resource::Parameters(Parameters {
427                parameter: Some(parameters),
428                ..Default::default()
429            })
430        }
431    }
432    #[derive(Debug, FromParameters)]
433    pub struct Output {
434        #[parameter_rename = "return"]
435        pub return_: CapabilityStatement,
436    }
437    impl From<Output> for Resource {
438        fn from(value: Output) -> Self {
439            Resource::CapabilityStatement(value.return_)
440        }
441    }
442}
443pub mod CapabilityStatementVersions {
444    use super::*;
445    pub const CODE: &str = "versions";
446    #[derive(Debug, FromParameters, ToParameters)]
447    pub struct Input {}
448    impl From<Input> for Resource {
449        fn from(value: Input) -> Self {
450            let parameters: Vec<ParametersParameter> = value.into();
451            Resource::Parameters(Parameters {
452                parameter: Some(parameters),
453                ..Default::default()
454            })
455        }
456    }
457    #[derive(Debug, FromParameters, ToParameters)]
458    pub struct Output {
459        pub version: Vec<FHIRCode>,
460        pub default: FHIRCode,
461    }
462    impl From<Output> for Resource {
463        fn from(value: Output) -> Self {
464            let parameters: Vec<ParametersParameter> = value.into();
465            Resource::Parameters(Parameters {
466                parameter: Some(parameters),
467                ..Default::default()
468            })
469        }
470    }
471}
472pub mod ChargeItemDefinitionApply {
473    use super::*;
474    pub const CODE: &str = "apply";
475    #[derive(Debug, FromParameters, ToParameters)]
476    pub struct Input {
477        pub chargeItem: Reference,
478        pub account: Option<Reference>,
479    }
480    impl From<Input> for Resource {
481        fn from(value: Input) -> Self {
482            let parameters: Vec<ParametersParameter> = value.into();
483            Resource::Parameters(Parameters {
484                parameter: Some(parameters),
485                ..Default::default()
486            })
487        }
488    }
489    #[derive(Debug, FromParameters)]
490    pub struct Output {
491        #[parameter_rename = "return"]
492        pub return_: Resource,
493    }
494    impl From<Output> for Resource {
495        fn from(value: Output) -> Self {
496            value.return_
497        }
498    }
499}
500pub mod ClaimSubmit {
501    use super::*;
502    pub const CODE: &str = "submit";
503    #[derive(Debug, FromParameters, ToParameters)]
504    pub struct Input {
505        pub resource: Resource,
506    }
507    impl From<Input> for Resource {
508        fn from(value: Input) -> Self {
509            let parameters: Vec<ParametersParameter> = value.into();
510            Resource::Parameters(Parameters {
511                parameter: Some(parameters),
512                ..Default::default()
513            })
514        }
515    }
516    #[derive(Debug, FromParameters, ToParameters)]
517    pub struct Output {
518        #[parameter_rename = "return"]
519        pub return_: Resource,
520    }
521    impl From<Output> for Resource {
522        fn from(value: Output) -> Self {
523            let parameters: Vec<ParametersParameter> = value.into();
524            Resource::Parameters(Parameters {
525                parameter: Some(parameters),
526                ..Default::default()
527            })
528        }
529    }
530}
531pub mod CodeSystemFindMatches {
532    use super::*;
533    pub const CODE: &str = "find-matches";
534    #[derive(Debug, FromParameters, ToParameters)]
535    pub struct InputPropertySubproperty {
536        pub code: FHIRCode,
537        pub value: ParametersParameterValueTypeChoice,
538    }
539    impl From<InputPropertySubproperty> for Resource {
540        fn from(value: InputPropertySubproperty) -> Self {
541            let parameters: Vec<ParametersParameter> = value.into();
542            Resource::Parameters(Parameters {
543                parameter: Some(parameters),
544                ..Default::default()
545            })
546        }
547    }
548    #[derive(Debug, FromParameters, ToParameters)]
549    pub struct InputProperty {
550        pub code: FHIRCode,
551        pub value: Option<ParametersParameterValueTypeChoice>,
552        #[parameter_nested]
553        pub subproperty: Option<Vec<InputPropertySubproperty>>,
554    }
555    impl From<InputProperty> for Resource {
556        fn from(value: InputProperty) -> Self {
557            let parameters: Vec<ParametersParameter> = value.into();
558            Resource::Parameters(Parameters {
559                parameter: Some(parameters),
560                ..Default::default()
561            })
562        }
563    }
564    #[derive(Debug, FromParameters, ToParameters)]
565    pub struct Input {
566        pub system: Option<FHIRUri>,
567        pub version: Option<FHIRString>,
568        #[parameter_nested]
569        pub property: Option<Vec<InputProperty>>,
570        pub exact: FHIRBoolean,
571        pub compositional: Option<FHIRBoolean>,
572    }
573    impl From<Input> for Resource {
574        fn from(value: Input) -> Self {
575            let parameters: Vec<ParametersParameter> = value.into();
576            Resource::Parameters(Parameters {
577                parameter: Some(parameters),
578                ..Default::default()
579            })
580        }
581    }
582    #[derive(Debug, FromParameters, ToParameters)]
583    pub struct OutputMatchUnmatchedProperty {
584        pub code: FHIRCode,
585        pub value: ParametersParameterValueTypeChoice,
586    }
587    impl From<OutputMatchUnmatchedProperty> for Resource {
588        fn from(value: OutputMatchUnmatchedProperty) -> Self {
589            let parameters: Vec<ParametersParameter> = value.into();
590            Resource::Parameters(Parameters {
591                parameter: Some(parameters),
592                ..Default::default()
593            })
594        }
595    }
596    #[derive(Debug, FromParameters, ToParameters)]
597    pub struct OutputMatchUnmatched {
598        pub code: FHIRCode,
599        pub value: ParametersParameterValueTypeChoice,
600        #[parameter_nested]
601        pub property: Option<Vec<OutputMatchUnmatchedProperty>>,
602    }
603    impl From<OutputMatchUnmatched> for Resource {
604        fn from(value: OutputMatchUnmatched) -> Self {
605            let parameters: Vec<ParametersParameter> = value.into();
606            Resource::Parameters(Parameters {
607                parameter: Some(parameters),
608                ..Default::default()
609            })
610        }
611    }
612    #[derive(Debug, FromParameters, ToParameters)]
613    pub struct OutputMatch {
614        pub code: Coding,
615        #[parameter_nested]
616        pub unmatched: Option<Vec<OutputMatchUnmatched>>,
617        pub comment: Option<FHIRString>,
618    }
619    impl From<OutputMatch> for Resource {
620        fn from(value: OutputMatch) -> Self {
621            let parameters: Vec<ParametersParameter> = value.into();
622            Resource::Parameters(Parameters {
623                parameter: Some(parameters),
624                ..Default::default()
625            })
626        }
627    }
628    #[derive(Debug, FromParameters, ToParameters)]
629    pub struct Output {
630        #[parameter_rename = "match"]
631        #[parameter_nested]
632        pub match_: Option<Vec<OutputMatch>>,
633    }
634    impl From<Output> for Resource {
635        fn from(value: Output) -> Self {
636            let parameters: Vec<ParametersParameter> = value.into();
637            Resource::Parameters(Parameters {
638                parameter: Some(parameters),
639                ..Default::default()
640            })
641        }
642    }
643}
644pub mod CodeSystemLookup {
645    use super::*;
646    pub const CODE: &str = "lookup";
647    #[derive(Debug, FromParameters, ToParameters)]
648    pub struct Input {
649        pub code: Option<FHIRCode>,
650        pub system: Option<FHIRUri>,
651        pub version: Option<FHIRString>,
652        pub coding: Option<Coding>,
653        pub date: Option<FHIRDateTime>,
654        pub displayLanguage: Option<FHIRCode>,
655        pub property: Option<Vec<FHIRCode>>,
656    }
657    impl From<Input> for Resource {
658        fn from(value: Input) -> Self {
659            let parameters: Vec<ParametersParameter> = value.into();
660            Resource::Parameters(Parameters {
661                parameter: Some(parameters),
662                ..Default::default()
663            })
664        }
665    }
666    #[derive(Debug, FromParameters, ToParameters)]
667    pub struct OutputDesignation {
668        pub language: Option<FHIRCode>,
669        #[parameter_rename = "use"]
670        pub use_: Option<Coding>,
671        pub value: FHIRString,
672    }
673    impl From<OutputDesignation> for Resource {
674        fn from(value: OutputDesignation) -> Self {
675            let parameters: Vec<ParametersParameter> = value.into();
676            Resource::Parameters(Parameters {
677                parameter: Some(parameters),
678                ..Default::default()
679            })
680        }
681    }
682    #[derive(Debug, FromParameters, ToParameters)]
683    pub struct OutputPropertySubproperty {
684        pub code: FHIRCode,
685        pub value: ParametersParameterValueTypeChoice,
686        pub description: Option<FHIRString>,
687    }
688    impl From<OutputPropertySubproperty> for Resource {
689        fn from(value: OutputPropertySubproperty) -> Self {
690            let parameters: Vec<ParametersParameter> = value.into();
691            Resource::Parameters(Parameters {
692                parameter: Some(parameters),
693                ..Default::default()
694            })
695        }
696    }
697    #[derive(Debug, FromParameters, ToParameters)]
698    pub struct OutputProperty {
699        pub code: FHIRCode,
700        pub value: Option<ParametersParameterValueTypeChoice>,
701        pub description: Option<FHIRString>,
702        #[parameter_nested]
703        pub subproperty: Option<Vec<OutputPropertySubproperty>>,
704    }
705    impl From<OutputProperty> for Resource {
706        fn from(value: OutputProperty) -> Self {
707            let parameters: Vec<ParametersParameter> = value.into();
708            Resource::Parameters(Parameters {
709                parameter: Some(parameters),
710                ..Default::default()
711            })
712        }
713    }
714    #[derive(Debug, FromParameters, ToParameters)]
715    pub struct Output {
716        pub name: FHIRString,
717        pub version: Option<FHIRString>,
718        pub display: FHIRString,
719        #[parameter_nested]
720        pub designation: Option<Vec<OutputDesignation>>,
721        #[parameter_nested]
722        pub property: Option<Vec<OutputProperty>>,
723    }
724    impl From<Output> for Resource {
725        fn from(value: Output) -> Self {
726            let parameters: Vec<ParametersParameter> = value.into();
727            Resource::Parameters(Parameters {
728                parameter: Some(parameters),
729                ..Default::default()
730            })
731        }
732    }
733}
734pub mod CodeSystemSubsumes {
735    use super::*;
736    pub const CODE: &str = "subsumes";
737    #[derive(Debug, FromParameters, ToParameters)]
738    pub struct Input {
739        pub codeA: Option<FHIRCode>,
740        pub codeB: Option<FHIRCode>,
741        pub system: Option<FHIRUri>,
742        pub version: Option<FHIRString>,
743        pub codingA: Option<Coding>,
744        pub codingB: Option<Coding>,
745    }
746    impl From<Input> for Resource {
747        fn from(value: Input) -> Self {
748            let parameters: Vec<ParametersParameter> = value.into();
749            Resource::Parameters(Parameters {
750                parameter: Some(parameters),
751                ..Default::default()
752            })
753        }
754    }
755    #[derive(Debug, FromParameters, ToParameters)]
756    pub struct Output {
757        pub outcome: FHIRCode,
758    }
759    impl From<Output> for Resource {
760        fn from(value: Output) -> Self {
761            let parameters: Vec<ParametersParameter> = value.into();
762            Resource::Parameters(Parameters {
763                parameter: Some(parameters),
764                ..Default::default()
765            })
766        }
767    }
768}
769pub mod CodeSystemValidateCode {
770    use super::*;
771    pub const CODE: &str = "validate-code";
772    #[derive(Debug, FromParameters, ToParameters)]
773    pub struct Input {
774        pub url: Option<FHIRUri>,
775        pub codeSystem: Option<CodeSystem>,
776        pub code: Option<FHIRCode>,
777        pub version: Option<FHIRString>,
778        pub display: Option<FHIRString>,
779        pub coding: Option<Coding>,
780        pub codeableConcept: Option<CodeableConcept>,
781        pub date: Option<FHIRDateTime>,
782        #[parameter_rename = "abstract"]
783        pub abstract_: Option<FHIRBoolean>,
784        pub displayLanguage: Option<FHIRCode>,
785    }
786    impl From<Input> for Resource {
787        fn from(value: Input) -> Self {
788            let parameters: Vec<ParametersParameter> = value.into();
789            Resource::Parameters(Parameters {
790                parameter: Some(parameters),
791                ..Default::default()
792            })
793        }
794    }
795    #[derive(Debug, FromParameters, ToParameters)]
796    pub struct Output {
797        pub result: FHIRBoolean,
798        pub message: Option<FHIRString>,
799        pub display: Option<FHIRString>,
800    }
801    impl From<Output> for Resource {
802        fn from(value: Output) -> Self {
803            let parameters: Vec<ParametersParameter> = value.into();
804            Resource::Parameters(Parameters {
805                parameter: Some(parameters),
806                ..Default::default()
807            })
808        }
809    }
810}
811pub mod CompositionDocument {
812    use super::*;
813    pub const CODE: &str = "document";
814    #[derive(Debug, FromParameters, ToParameters)]
815    pub struct Input {
816        pub id: Option<FHIRUri>,
817        pub persist: Option<FHIRBoolean>,
818        pub graph: Option<FHIRUri>,
819    }
820    impl From<Input> for Resource {
821        fn from(value: Input) -> Self {
822            let parameters: Vec<ParametersParameter> = value.into();
823            Resource::Parameters(Parameters {
824                parameter: Some(parameters),
825                ..Default::default()
826            })
827        }
828    }
829    #[derive(Debug, FromParameters, ToParameters)]
830    pub struct Output {}
831    impl From<Output> for Resource {
832        fn from(value: Output) -> Self {
833            let parameters: Vec<ParametersParameter> = value.into();
834            Resource::Parameters(Parameters {
835                parameter: Some(parameters),
836                ..Default::default()
837            })
838        }
839    }
840}
841pub mod ConceptMapClosure {
842    use super::*;
843    pub const CODE: &str = "closure";
844    #[derive(Debug, FromParameters, ToParameters)]
845    pub struct Input {
846        pub name: FHIRString,
847        pub concept: Option<Vec<Coding>>,
848        pub version: Option<FHIRString>,
849    }
850    impl From<Input> for Resource {
851        fn from(value: Input) -> Self {
852            let parameters: Vec<ParametersParameter> = value.into();
853            Resource::Parameters(Parameters {
854                parameter: Some(parameters),
855                ..Default::default()
856            })
857        }
858    }
859    #[derive(Debug, FromParameters)]
860    pub struct Output {
861        #[parameter_rename = "return"]
862        pub return_: ConceptMap,
863    }
864    impl From<Output> for Resource {
865        fn from(value: Output) -> Self {
866            Resource::ConceptMap(value.return_)
867        }
868    }
869}
870pub mod ConceptMapTranslate {
871    use super::*;
872    pub const CODE: &str = "translate";
873    #[derive(Debug, FromParameters, ToParameters)]
874    pub struct InputDependency {
875        pub element: Option<FHIRUri>,
876        pub concept: Option<CodeableConcept>,
877    }
878    impl From<InputDependency> for Resource {
879        fn from(value: InputDependency) -> Self {
880            let parameters: Vec<ParametersParameter> = value.into();
881            Resource::Parameters(Parameters {
882                parameter: Some(parameters),
883                ..Default::default()
884            })
885        }
886    }
887    #[derive(Debug, FromParameters, ToParameters)]
888    pub struct Input {
889        pub url: Option<FHIRUri>,
890        pub conceptMap: Option<ConceptMap>,
891        pub conceptMapVersion: Option<FHIRString>,
892        pub code: Option<FHIRCode>,
893        pub system: Option<FHIRUri>,
894        pub version: Option<FHIRString>,
895        pub source: Option<FHIRUri>,
896        pub coding: Option<Coding>,
897        pub codeableConcept: Option<CodeableConcept>,
898        pub target: Option<FHIRUri>,
899        pub targetsystem: Option<FHIRUri>,
900        #[parameter_nested]
901        pub dependency: Option<Vec<InputDependency>>,
902        pub reverse: Option<FHIRBoolean>,
903    }
904    impl From<Input> for Resource {
905        fn from(value: Input) -> Self {
906            let parameters: Vec<ParametersParameter> = value.into();
907            Resource::Parameters(Parameters {
908                parameter: Some(parameters),
909                ..Default::default()
910            })
911        }
912    }
913    #[derive(Debug, FromParameters, ToParameters)]
914    pub struct OutputMatchProduct {
915        pub element: Option<FHIRUri>,
916        pub concept: Option<Coding>,
917    }
918    impl From<OutputMatchProduct> for Resource {
919        fn from(value: OutputMatchProduct) -> Self {
920            let parameters: Vec<ParametersParameter> = value.into();
921            Resource::Parameters(Parameters {
922                parameter: Some(parameters),
923                ..Default::default()
924            })
925        }
926    }
927    #[derive(Debug, FromParameters, ToParameters)]
928    pub struct OutputMatch {
929        pub equivalence: Option<FHIRCode>,
930        pub concept: Option<Coding>,
931        #[parameter_nested]
932        pub product: Option<Vec<OutputMatchProduct>>,
933        pub source: Option<FHIRUri>,
934    }
935    impl From<OutputMatch> for Resource {
936        fn from(value: OutputMatch) -> Self {
937            let parameters: Vec<ParametersParameter> = value.into();
938            Resource::Parameters(Parameters {
939                parameter: Some(parameters),
940                ..Default::default()
941            })
942        }
943    }
944    #[derive(Debug, FromParameters, ToParameters)]
945    pub struct Output {
946        pub result: FHIRBoolean,
947        pub message: Option<FHIRString>,
948        #[parameter_rename = "match"]
949        #[parameter_nested]
950        pub match_: Option<Vec<OutputMatch>>,
951    }
952    impl From<Output> for Resource {
953        fn from(value: Output) -> Self {
954            let parameters: Vec<ParametersParameter> = value.into();
955            Resource::Parameters(Parameters {
956                parameter: Some(parameters),
957                ..Default::default()
958            })
959        }
960    }
961}
962pub mod CoverageEligibilityRequestSubmit {
963    use super::*;
964    pub const CODE: &str = "submit";
965    #[derive(Debug, FromParameters, ToParameters)]
966    pub struct Input {
967        pub resource: Resource,
968    }
969    impl From<Input> for Resource {
970        fn from(value: Input) -> Self {
971            let parameters: Vec<ParametersParameter> = value.into();
972            Resource::Parameters(Parameters {
973                parameter: Some(parameters),
974                ..Default::default()
975            })
976        }
977    }
978    #[derive(Debug, FromParameters, ToParameters)]
979    pub struct Output {
980        #[parameter_rename = "return"]
981        pub return_: Resource,
982    }
983    impl From<Output> for Resource {
984        fn from(value: Output) -> Self {
985            let parameters: Vec<ParametersParameter> = value.into();
986            Resource::Parameters(Parameters {
987                parameter: Some(parameters),
988                ..Default::default()
989            })
990        }
991    }
992}
993pub mod EncounterEverything {
994    use super::*;
995    pub const CODE: &str = "everything";
996    #[derive(Debug, FromParameters, ToParameters)]
997    pub struct Input {
998        pub _since: Option<FHIRInstant>,
999        pub _type: Option<Vec<FHIRCode>>,
1000        pub _count: Option<FHIRInteger>,
1001    }
1002    impl From<Input> for Resource {
1003        fn from(value: Input) -> Self {
1004            let parameters: Vec<ParametersParameter> = value.into();
1005            Resource::Parameters(Parameters {
1006                parameter: Some(parameters),
1007                ..Default::default()
1008            })
1009        }
1010    }
1011    #[derive(Debug, FromParameters)]
1012    pub struct Output {
1013        #[parameter_rename = "return"]
1014        pub return_: Bundle,
1015    }
1016    impl From<Output> for Resource {
1017        fn from(value: Output) -> Self {
1018            Resource::Bundle(value.return_)
1019        }
1020    }
1021}
1022pub mod GroupEverything {
1023    use super::*;
1024    pub const CODE: &str = "everything";
1025    #[derive(Debug, FromParameters, ToParameters)]
1026    pub struct Input {
1027        pub start: Option<FHIRDate>,
1028        pub end: Option<FHIRDate>,
1029        pub _since: Option<FHIRInstant>,
1030        pub _type: Option<Vec<FHIRCode>>,
1031        pub _count: Option<FHIRInteger>,
1032    }
1033    impl From<Input> for Resource {
1034        fn from(value: Input) -> Self {
1035            let parameters: Vec<ParametersParameter> = value.into();
1036            Resource::Parameters(Parameters {
1037                parameter: Some(parameters),
1038                ..Default::default()
1039            })
1040        }
1041    }
1042    #[derive(Debug, FromParameters)]
1043    pub struct Output {
1044        #[parameter_rename = "return"]
1045        pub return_: Bundle,
1046    }
1047    impl From<Output> for Resource {
1048        fn from(value: Output) -> Self {
1049            Resource::Bundle(value.return_)
1050        }
1051    }
1052}
1053pub mod LibraryDataRequirements {
1054    use super::*;
1055    pub const CODE: &str = "data-requirements";
1056    #[derive(Debug, FromParameters, ToParameters)]
1057    pub struct Input {
1058        pub target: Option<FHIRString>,
1059    }
1060    impl From<Input> for Resource {
1061        fn from(value: Input) -> Self {
1062            let parameters: Vec<ParametersParameter> = value.into();
1063            Resource::Parameters(Parameters {
1064                parameter: Some(parameters),
1065                ..Default::default()
1066            })
1067        }
1068    }
1069    #[derive(Debug, FromParameters)]
1070    pub struct Output {
1071        #[parameter_rename = "return"]
1072        pub return_: Library,
1073    }
1074    impl From<Output> for Resource {
1075        fn from(value: Output) -> Self {
1076            Resource::Library(value.return_)
1077        }
1078    }
1079}
1080pub mod ListFind {
1081    use super::*;
1082    pub const CODE: &str = "find";
1083    #[derive(Debug, FromParameters, ToParameters)]
1084    pub struct Input {
1085        pub patient: FHIRId,
1086        pub name: FHIRCode,
1087    }
1088    impl From<Input> for Resource {
1089        fn from(value: Input) -> Self {
1090            let parameters: Vec<ParametersParameter> = value.into();
1091            Resource::Parameters(Parameters {
1092                parameter: Some(parameters),
1093                ..Default::default()
1094            })
1095        }
1096    }
1097    #[derive(Debug, FromParameters, ToParameters)]
1098    pub struct Output {}
1099    impl From<Output> for Resource {
1100        fn from(value: Output) -> Self {
1101            let parameters: Vec<ParametersParameter> = value.into();
1102            Resource::Parameters(Parameters {
1103                parameter: Some(parameters),
1104                ..Default::default()
1105            })
1106        }
1107    }
1108}
1109pub mod MeasureCareGaps {
1110    use super::*;
1111    pub const CODE: &str = "care-gaps";
1112    #[derive(Debug, FromParameters, ToParameters)]
1113    pub struct Input {
1114        pub periodStart: FHIRDate,
1115        pub periodEnd: FHIRDate,
1116        pub topic: FHIRString,
1117        pub subject: FHIRString,
1118    }
1119    impl From<Input> for Resource {
1120        fn from(value: Input) -> Self {
1121            let parameters: Vec<ParametersParameter> = value.into();
1122            Resource::Parameters(Parameters {
1123                parameter: Some(parameters),
1124                ..Default::default()
1125            })
1126        }
1127    }
1128    #[derive(Debug, FromParameters)]
1129    pub struct Output {
1130        #[parameter_rename = "return"]
1131        pub return_: Bundle,
1132    }
1133    impl From<Output> for Resource {
1134        fn from(value: Output) -> Self {
1135            Resource::Bundle(value.return_)
1136        }
1137    }
1138}
1139pub mod MeasureCollectData {
1140    use super::*;
1141    pub const CODE: &str = "collect-data";
1142    #[derive(Debug, FromParameters, ToParameters)]
1143    pub struct Input {
1144        pub periodStart: FHIRDate,
1145        pub periodEnd: FHIRDate,
1146        pub measure: Option<FHIRString>,
1147        pub subject: Option<FHIRString>,
1148        pub practitioner: Option<FHIRString>,
1149        pub lastReceivedOn: Option<FHIRDateTime>,
1150    }
1151    impl From<Input> for Resource {
1152        fn from(value: Input) -> Self {
1153            let parameters: Vec<ParametersParameter> = value.into();
1154            Resource::Parameters(Parameters {
1155                parameter: Some(parameters),
1156                ..Default::default()
1157            })
1158        }
1159    }
1160    #[derive(Debug, FromParameters, ToParameters)]
1161    pub struct Output {
1162        pub measureReport: MeasureReport,
1163        pub resource: Option<Vec<Resource>>,
1164    }
1165    impl From<Output> for Resource {
1166        fn from(value: Output) -> Self {
1167            let parameters: Vec<ParametersParameter> = value.into();
1168            Resource::Parameters(Parameters {
1169                parameter: Some(parameters),
1170                ..Default::default()
1171            })
1172        }
1173    }
1174}
1175pub mod MeasureDataRequirements {
1176    use super::*;
1177    pub const CODE: &str = "data-requirements";
1178    #[derive(Debug, FromParameters, ToParameters)]
1179    pub struct Input {
1180        pub periodStart: FHIRDate,
1181        pub periodEnd: FHIRDate,
1182    }
1183    impl From<Input> for Resource {
1184        fn from(value: Input) -> Self {
1185            let parameters: Vec<ParametersParameter> = value.into();
1186            Resource::Parameters(Parameters {
1187                parameter: Some(parameters),
1188                ..Default::default()
1189            })
1190        }
1191    }
1192    #[derive(Debug, FromParameters)]
1193    pub struct Output {
1194        #[parameter_rename = "return"]
1195        pub return_: Library,
1196    }
1197    impl From<Output> for Resource {
1198        fn from(value: Output) -> Self {
1199            Resource::Library(value.return_)
1200        }
1201    }
1202}
1203pub mod MeasureEvaluateMeasure {
1204    use super::*;
1205    pub const CODE: &str = "evaluate-measure";
1206    #[derive(Debug, FromParameters, ToParameters)]
1207    pub struct Input {
1208        pub periodStart: FHIRDate,
1209        pub periodEnd: FHIRDate,
1210        pub measure: Option<FHIRString>,
1211        pub reportType: Option<FHIRCode>,
1212        pub subject: Option<FHIRString>,
1213        pub practitioner: Option<FHIRString>,
1214        pub lastReceivedOn: Option<FHIRDateTime>,
1215    }
1216    impl From<Input> for Resource {
1217        fn from(value: Input) -> Self {
1218            let parameters: Vec<ParametersParameter> = value.into();
1219            Resource::Parameters(Parameters {
1220                parameter: Some(parameters),
1221                ..Default::default()
1222            })
1223        }
1224    }
1225    #[derive(Debug, FromParameters)]
1226    pub struct Output {
1227        #[parameter_rename = "return"]
1228        pub return_: MeasureReport,
1229    }
1230    impl From<Output> for Resource {
1231        fn from(value: Output) -> Self {
1232            Resource::MeasureReport(value.return_)
1233        }
1234    }
1235}
1236pub mod MeasureSubmitData {
1237    use super::*;
1238    pub const CODE: &str = "submit-data";
1239    #[derive(Debug, FromParameters, ToParameters)]
1240    pub struct Input {
1241        pub measureReport: MeasureReport,
1242        pub resource: Option<Vec<Resource>>,
1243    }
1244    impl From<Input> for Resource {
1245        fn from(value: Input) -> Self {
1246            let parameters: Vec<ParametersParameter> = value.into();
1247            Resource::Parameters(Parameters {
1248                parameter: Some(parameters),
1249                ..Default::default()
1250            })
1251        }
1252    }
1253    #[derive(Debug, FromParameters, ToParameters)]
1254    pub struct Output {}
1255    impl From<Output> for Resource {
1256        fn from(value: Output) -> Self {
1257            let parameters: Vec<ParametersParameter> = value.into();
1258            Resource::Parameters(Parameters {
1259                parameter: Some(parameters),
1260                ..Default::default()
1261            })
1262        }
1263    }
1264}
1265pub mod MedicinalProductEverything {
1266    use super::*;
1267    pub const CODE: &str = "everything";
1268    #[derive(Debug, FromParameters, ToParameters)]
1269    pub struct Input {
1270        pub _since: Option<FHIRInstant>,
1271        pub _count: Option<FHIRInteger>,
1272    }
1273    impl From<Input> for Resource {
1274        fn from(value: Input) -> Self {
1275            let parameters: Vec<ParametersParameter> = value.into();
1276            Resource::Parameters(Parameters {
1277                parameter: Some(parameters),
1278                ..Default::default()
1279            })
1280        }
1281    }
1282    #[derive(Debug, FromParameters)]
1283    pub struct Output {
1284        #[parameter_rename = "return"]
1285        pub return_: Bundle,
1286    }
1287    impl From<Output> for Resource {
1288        fn from(value: Output) -> Self {
1289            Resource::Bundle(value.return_)
1290        }
1291    }
1292}
1293pub mod MessageHeaderProcessMessage {
1294    use super::*;
1295    pub const CODE: &str = "process-message";
1296    #[derive(Debug, FromParameters, ToParameters)]
1297    pub struct Input {
1298        pub content: Bundle,
1299        #[parameter_rename = "async"]
1300        pub async_: Option<FHIRBoolean>,
1301        #[parameter_rename = "response-url"]
1302        pub response_url: Option<FHIRUrl>,
1303    }
1304    impl From<Input> for Resource {
1305        fn from(value: Input) -> Self {
1306            let parameters: Vec<ParametersParameter> = value.into();
1307            Resource::Parameters(Parameters {
1308                parameter: Some(parameters),
1309                ..Default::default()
1310            })
1311        }
1312    }
1313    #[derive(Debug, FromParameters)]
1314    pub struct Output {
1315        #[parameter_rename = "return"]
1316        pub return_: Option<Bundle>,
1317    }
1318    impl From<Output> for Resource {
1319        fn from(value: Output) -> Self {
1320            Resource::Bundle(value.return_.unwrap_or_default())
1321        }
1322    }
1323}
1324pub mod NamingSystemPreferredId {
1325    use super::*;
1326    pub const CODE: &str = "preferred-id";
1327    #[derive(Debug, FromParameters, ToParameters)]
1328    pub struct Input {
1329        pub id: FHIRString,
1330        #[parameter_rename = "type"]
1331        pub type_: FHIRCode,
1332    }
1333    impl From<Input> for Resource {
1334        fn from(value: Input) -> Self {
1335            let parameters: Vec<ParametersParameter> = value.into();
1336            Resource::Parameters(Parameters {
1337                parameter: Some(parameters),
1338                ..Default::default()
1339            })
1340        }
1341    }
1342    #[derive(Debug, FromParameters, ToParameters)]
1343    pub struct Output {
1344        pub result: FHIRString,
1345    }
1346    impl From<Output> for Resource {
1347        fn from(value: Output) -> Self {
1348            let parameters: Vec<ParametersParameter> = value.into();
1349            Resource::Parameters(Parameters {
1350                parameter: Some(parameters),
1351                ..Default::default()
1352            })
1353        }
1354    }
1355}
1356pub mod ObservationLastn {
1357    use super::*;
1358    pub const CODE: &str = "lastn";
1359    #[derive(Debug, FromParameters, ToParameters)]
1360    pub struct Input {
1361        pub max: Option<FHIRPositiveInt>,
1362    }
1363    impl From<Input> for Resource {
1364        fn from(value: Input) -> Self {
1365            let parameters: Vec<ParametersParameter> = value.into();
1366            Resource::Parameters(Parameters {
1367                parameter: Some(parameters),
1368                ..Default::default()
1369            })
1370        }
1371    }
1372    #[derive(Debug, FromParameters)]
1373    pub struct Output {
1374        #[parameter_rename = "return"]
1375        pub return_: Bundle,
1376    }
1377    impl From<Output> for Resource {
1378        fn from(value: Output) -> Self {
1379            Resource::Bundle(value.return_)
1380        }
1381    }
1382}
1383pub mod ObservationStats {
1384    use super::*;
1385    pub const CODE: &str = "stats";
1386    #[derive(Debug, FromParameters, ToParameters)]
1387    pub struct Input {
1388        pub subject: FHIRUri,
1389        pub code: Option<Vec<FHIRString>>,
1390        pub system: Option<FHIRUri>,
1391        pub coding: Option<Vec<Coding>>,
1392        pub duration: Option<FHIRDecimal>,
1393        pub period: Option<Period>,
1394        pub statistic: Vec<FHIRCode>,
1395        pub include: Option<FHIRBoolean>,
1396        pub limit: Option<FHIRPositiveInt>,
1397    }
1398    impl From<Input> for Resource {
1399        fn from(value: Input) -> Self {
1400            let parameters: Vec<ParametersParameter> = value.into();
1401            Resource::Parameters(Parameters {
1402                parameter: Some(parameters),
1403                ..Default::default()
1404            })
1405        }
1406    }
1407    #[derive(Debug, FromParameters, ToParameters)]
1408    pub struct Output {
1409        pub statistics: Vec<Observation>,
1410        pub source: Option<Vec<Observation>>,
1411    }
1412    impl From<Output> for Resource {
1413        fn from(value: Output) -> Self {
1414            let parameters: Vec<ParametersParameter> = value.into();
1415            Resource::Parameters(Parameters {
1416                parameter: Some(parameters),
1417                ..Default::default()
1418            })
1419        }
1420    }
1421}
1422pub mod PatientEverything {
1423    use super::*;
1424    pub const CODE: &str = "everything";
1425    #[derive(Debug, FromParameters, ToParameters)]
1426    pub struct Input {
1427        pub start: Option<FHIRDate>,
1428        pub end: Option<FHIRDate>,
1429        pub _since: Option<FHIRInstant>,
1430        pub _type: Option<Vec<FHIRCode>>,
1431        pub _count: Option<FHIRInteger>,
1432    }
1433    impl From<Input> for Resource {
1434        fn from(value: Input) -> Self {
1435            let parameters: Vec<ParametersParameter> = value.into();
1436            Resource::Parameters(Parameters {
1437                parameter: Some(parameters),
1438                ..Default::default()
1439            })
1440        }
1441    }
1442    #[derive(Debug, FromParameters)]
1443    pub struct Output {
1444        #[parameter_rename = "return"]
1445        pub return_: Bundle,
1446    }
1447    impl From<Output> for Resource {
1448        fn from(value: Output) -> Self {
1449            Resource::Bundle(value.return_)
1450        }
1451    }
1452}
1453pub mod PatientMatch {
1454    use super::*;
1455    pub const CODE: &str = "match";
1456    #[derive(Debug, FromParameters, ToParameters)]
1457    pub struct Input {
1458        pub resource: Resource,
1459        pub onlyCertainMatches: Option<FHIRBoolean>,
1460        pub count: Option<FHIRInteger>,
1461    }
1462    impl From<Input> for Resource {
1463        fn from(value: Input) -> Self {
1464            let parameters: Vec<ParametersParameter> = value.into();
1465            Resource::Parameters(Parameters {
1466                parameter: Some(parameters),
1467                ..Default::default()
1468            })
1469        }
1470    }
1471    #[derive(Debug, FromParameters)]
1472    pub struct Output {
1473        #[parameter_rename = "return"]
1474        pub return_: Bundle,
1475    }
1476    impl From<Output> for Resource {
1477        fn from(value: Output) -> Self {
1478            Resource::Bundle(value.return_)
1479        }
1480    }
1481}
1482pub mod PlanDefinitionApply {
1483    use super::*;
1484    pub const CODE: &str = "apply";
1485    #[derive(Debug, FromParameters, ToParameters)]
1486    pub struct Input {
1487        pub planDefinition: Option<PlanDefinition>,
1488        pub subject: Vec<FHIRString>,
1489        pub encounter: Option<FHIRString>,
1490        pub practitioner: Option<FHIRString>,
1491        pub organization: Option<FHIRString>,
1492        pub userType: Option<CodeableConcept>,
1493        pub userLanguage: Option<CodeableConcept>,
1494        pub userTaskContext: Option<CodeableConcept>,
1495        pub setting: Option<CodeableConcept>,
1496        pub settingContext: Option<CodeableConcept>,
1497    }
1498    impl From<Input> for Resource {
1499        fn from(value: Input) -> Self {
1500            let parameters: Vec<ParametersParameter> = value.into();
1501            Resource::Parameters(Parameters {
1502                parameter: Some(parameters),
1503                ..Default::default()
1504            })
1505        }
1506    }
1507    #[derive(Debug, FromParameters)]
1508    pub struct Output {
1509        #[parameter_rename = "return"]
1510        pub return_: CarePlan,
1511    }
1512    impl From<Output> for Resource {
1513        fn from(value: Output) -> Self {
1514            Resource::CarePlan(value.return_)
1515        }
1516    }
1517}
1518pub mod PlanDefinitionDataRequirements {
1519    use super::*;
1520    pub const CODE: &str = "data-requirements";
1521    #[derive(Debug, FromParameters, ToParameters)]
1522    pub struct Input {}
1523    impl From<Input> for Resource {
1524        fn from(value: Input) -> Self {
1525            let parameters: Vec<ParametersParameter> = value.into();
1526            Resource::Parameters(Parameters {
1527                parameter: Some(parameters),
1528                ..Default::default()
1529            })
1530        }
1531    }
1532    #[derive(Debug, FromParameters)]
1533    pub struct Output {
1534        #[parameter_rename = "return"]
1535        pub return_: Library,
1536    }
1537    impl From<Output> for Resource {
1538        fn from(value: Output) -> Self {
1539            Resource::Library(value.return_)
1540        }
1541    }
1542}
1543pub mod ResourceConvert {
1544    use super::*;
1545    pub const CODE: &str = "convert";
1546    #[derive(Debug, FromParameters, ToParameters)]
1547    pub struct Input {
1548        pub input: Resource,
1549    }
1550    impl From<Input> for Resource {
1551        fn from(value: Input) -> Self {
1552            let parameters: Vec<ParametersParameter> = value.into();
1553            Resource::Parameters(Parameters {
1554                parameter: Some(parameters),
1555                ..Default::default()
1556            })
1557        }
1558    }
1559    #[derive(Debug, FromParameters, ToParameters)]
1560    pub struct Output {
1561        pub output: Resource,
1562    }
1563    impl From<Output> for Resource {
1564        fn from(value: Output) -> Self {
1565            let parameters: Vec<ParametersParameter> = value.into();
1566            Resource::Parameters(Parameters {
1567                parameter: Some(parameters),
1568                ..Default::default()
1569            })
1570        }
1571    }
1572}
1573pub mod ResourceGraph {
1574    use super::*;
1575    pub const CODE: &str = "graph";
1576    #[derive(Debug, FromParameters, ToParameters)]
1577    pub struct Input {
1578        pub graph: FHIRUri,
1579    }
1580    impl From<Input> for Resource {
1581        fn from(value: Input) -> Self {
1582            let parameters: Vec<ParametersParameter> = value.into();
1583            Resource::Parameters(Parameters {
1584                parameter: Some(parameters),
1585                ..Default::default()
1586            })
1587        }
1588    }
1589    #[derive(Debug, FromParameters, ToParameters)]
1590    pub struct Output {
1591        pub result: Bundle,
1592    }
1593    impl From<Output> for Resource {
1594        fn from(value: Output) -> Self {
1595            let parameters: Vec<ParametersParameter> = value.into();
1596            Resource::Parameters(Parameters {
1597                parameter: Some(parameters),
1598                ..Default::default()
1599            })
1600        }
1601    }
1602}
1603pub mod ResourceGraphql {
1604    use super::*;
1605    pub const CODE: &str = "graphql";
1606    #[derive(Debug, FromParameters, ToParameters)]
1607    pub struct Input {
1608        pub query: FHIRString,
1609    }
1610    impl From<Input> for Resource {
1611        fn from(value: Input) -> Self {
1612            let parameters: Vec<ParametersParameter> = value.into();
1613            Resource::Parameters(Parameters {
1614                parameter: Some(parameters),
1615                ..Default::default()
1616            })
1617        }
1618    }
1619    #[derive(Debug, FromParameters, ToParameters)]
1620    pub struct Output {
1621        pub result: Binary,
1622    }
1623    impl From<Output> for Resource {
1624        fn from(value: Output) -> Self {
1625            let parameters: Vec<ParametersParameter> = value.into();
1626            Resource::Parameters(Parameters {
1627                parameter: Some(parameters),
1628                ..Default::default()
1629            })
1630        }
1631    }
1632}
1633pub mod ResourceMeta {
1634    use super::*;
1635    pub const CODE: &str = "meta";
1636    #[derive(Debug, FromParameters, ToParameters)]
1637    pub struct Input {}
1638    impl From<Input> for Resource {
1639        fn from(value: Input) -> Self {
1640            let parameters: Vec<ParametersParameter> = value.into();
1641            Resource::Parameters(Parameters {
1642                parameter: Some(parameters),
1643                ..Default::default()
1644            })
1645        }
1646    }
1647    #[derive(Debug, FromParameters, ToParameters)]
1648    pub struct Output {
1649        #[parameter_rename = "return"]
1650        pub return_: Meta,
1651    }
1652    impl From<Output> for Resource {
1653        fn from(value: Output) -> Self {
1654            let parameters: Vec<ParametersParameter> = value.into();
1655            Resource::Parameters(Parameters {
1656                parameter: Some(parameters),
1657                ..Default::default()
1658            })
1659        }
1660    }
1661}
1662pub mod ResourceMetaAdd {
1663    use super::*;
1664    pub const CODE: &str = "meta-add";
1665    #[derive(Debug, FromParameters, ToParameters)]
1666    pub struct Input {
1667        pub meta: Meta,
1668    }
1669    impl From<Input> for Resource {
1670        fn from(value: Input) -> Self {
1671            let parameters: Vec<ParametersParameter> = value.into();
1672            Resource::Parameters(Parameters {
1673                parameter: Some(parameters),
1674                ..Default::default()
1675            })
1676        }
1677    }
1678    #[derive(Debug, FromParameters, ToParameters)]
1679    pub struct Output {
1680        #[parameter_rename = "return"]
1681        pub return_: Meta,
1682    }
1683    impl From<Output> for Resource {
1684        fn from(value: Output) -> Self {
1685            let parameters: Vec<ParametersParameter> = value.into();
1686            Resource::Parameters(Parameters {
1687                parameter: Some(parameters),
1688                ..Default::default()
1689            })
1690        }
1691    }
1692}
1693pub mod ResourceMetaDelete {
1694    use super::*;
1695    pub const CODE: &str = "meta-delete";
1696    #[derive(Debug, FromParameters, ToParameters)]
1697    pub struct Input {
1698        pub meta: Meta,
1699    }
1700    impl From<Input> for Resource {
1701        fn from(value: Input) -> Self {
1702            let parameters: Vec<ParametersParameter> = value.into();
1703            Resource::Parameters(Parameters {
1704                parameter: Some(parameters),
1705                ..Default::default()
1706            })
1707        }
1708    }
1709    #[derive(Debug, FromParameters, ToParameters)]
1710    pub struct Output {
1711        #[parameter_rename = "return"]
1712        pub return_: Meta,
1713    }
1714    impl From<Output> for Resource {
1715        fn from(value: Output) -> Self {
1716            let parameters: Vec<ParametersParameter> = value.into();
1717            Resource::Parameters(Parameters {
1718                parameter: Some(parameters),
1719                ..Default::default()
1720            })
1721        }
1722    }
1723}
1724pub mod ResourceValidate {
1725    use super::*;
1726    pub const CODE: &str = "validate";
1727    #[derive(Debug, FromParameters, ToParameters)]
1728    pub struct Input {
1729        pub resource: Option<Resource>,
1730        pub mode: Option<FHIRCode>,
1731        pub profile: Option<FHIRUri>,
1732    }
1733    impl From<Input> for Resource {
1734        fn from(value: Input) -> Self {
1735            let parameters: Vec<ParametersParameter> = value.into();
1736            Resource::Parameters(Parameters {
1737                parameter: Some(parameters),
1738                ..Default::default()
1739            })
1740        }
1741    }
1742    #[derive(Debug, FromParameters)]
1743    pub struct Output {
1744        #[parameter_rename = "return"]
1745        pub return_: OperationOutcome,
1746    }
1747    impl From<Output> for Resource {
1748        fn from(value: Output) -> Self {
1749            Resource::OperationOutcome(value.return_)
1750        }
1751    }
1752}
1753pub mod StructureDefinitionQuestionnaire {
1754    use super::*;
1755    pub const CODE: &str = "questionnaire";
1756    #[derive(Debug, FromParameters, ToParameters)]
1757    pub struct Input {
1758        #[parameter_rename = "identifier"]
1759        pub identifier_: Option<FHIRString>,
1760        pub profile: Option<FHIRString>,
1761        pub url: Option<FHIRString>,
1762        pub supportedOnly: Option<FHIRBoolean>,
1763    }
1764    impl From<Input> for Resource {
1765        fn from(value: Input) -> Self {
1766            let parameters: Vec<ParametersParameter> = value.into();
1767            Resource::Parameters(Parameters {
1768                parameter: Some(parameters),
1769                ..Default::default()
1770            })
1771        }
1772    }
1773    #[derive(Debug, FromParameters)]
1774    pub struct Output {
1775        #[parameter_rename = "return"]
1776        pub return_: Questionnaire,
1777    }
1778    impl From<Output> for Resource {
1779        fn from(value: Output) -> Self {
1780            Resource::Questionnaire(value.return_)
1781        }
1782    }
1783}
1784pub mod StructureDefinitionSnapshot {
1785    use super::*;
1786    pub const CODE: &str = "snapshot";
1787    #[derive(Debug, FromParameters, ToParameters)]
1788    pub struct Input {
1789        pub definition: Option<StructureDefinition>,
1790        pub url: Option<FHIRString>,
1791    }
1792    impl From<Input> for Resource {
1793        fn from(value: Input) -> Self {
1794            let parameters: Vec<ParametersParameter> = value.into();
1795            Resource::Parameters(Parameters {
1796                parameter: Some(parameters),
1797                ..Default::default()
1798            })
1799        }
1800    }
1801    #[derive(Debug, FromParameters)]
1802    pub struct Output {
1803        #[parameter_rename = "return"]
1804        pub return_: StructureDefinition,
1805    }
1806    impl From<Output> for Resource {
1807        fn from(value: Output) -> Self {
1808            Resource::StructureDefinition(value.return_)
1809        }
1810    }
1811}
1812pub mod StructureMapTransform {
1813    use super::*;
1814    pub const CODE: &str = "transform";
1815    #[derive(Debug, FromParameters, ToParameters)]
1816    pub struct Input {
1817        pub source: Option<FHIRUri>,
1818        pub content: Resource,
1819    }
1820    impl From<Input> for Resource {
1821        fn from(value: Input) -> Self {
1822            let parameters: Vec<ParametersParameter> = value.into();
1823            Resource::Parameters(Parameters {
1824                parameter: Some(parameters),
1825                ..Default::default()
1826            })
1827        }
1828    }
1829    #[derive(Debug, FromParameters, ToParameters)]
1830    pub struct Output {
1831        #[parameter_rename = "return"]
1832        pub return_: Resource,
1833    }
1834    impl From<Output> for Resource {
1835        fn from(value: Output) -> Self {
1836            let parameters: Vec<ParametersParameter> = value.into();
1837            Resource::Parameters(Parameters {
1838                parameter: Some(parameters),
1839                ..Default::default()
1840            })
1841        }
1842    }
1843}
1844pub mod ValueSetExpand {
1845    use super::*;
1846    pub const CODE: &str = "expand";
1847    #[derive(Debug, FromParameters, ToParameters)]
1848    pub struct Input {
1849        pub url: Option<FHIRUri>,
1850        pub valueSet: Option<ValueSet>,
1851        pub valueSetVersion: Option<FHIRString>,
1852        pub context: Option<FHIRUri>,
1853        pub contextDirection: Option<FHIRCode>,
1854        pub filter: Option<FHIRString>,
1855        pub date: Option<FHIRDateTime>,
1856        pub offset: Option<FHIRInteger>,
1857        pub count: Option<FHIRInteger>,
1858        pub includeDesignations: Option<FHIRBoolean>,
1859        pub designation: Option<Vec<FHIRString>>,
1860        pub includeDefinition: Option<FHIRBoolean>,
1861        pub activeOnly: Option<FHIRBoolean>,
1862        pub excludeNested: Option<FHIRBoolean>,
1863        pub excludeNotForUI: Option<FHIRBoolean>,
1864        pub excludePostCoordinated: Option<FHIRBoolean>,
1865        pub displayLanguage: Option<FHIRCode>,
1866        #[parameter_rename = "exclude-system"]
1867        pub exclude_system: Option<Vec<FHIRString>>,
1868        #[parameter_rename = "system-version"]
1869        pub system_version: Option<Vec<FHIRString>>,
1870        #[parameter_rename = "check-system-version"]
1871        pub check_system_version: Option<Vec<FHIRString>>,
1872        #[parameter_rename = "force-system-version"]
1873        pub force_system_version: Option<Vec<FHIRString>>,
1874    }
1875    impl From<Input> for Resource {
1876        fn from(value: Input) -> Self {
1877            let parameters: Vec<ParametersParameter> = value.into();
1878            Resource::Parameters(Parameters {
1879                parameter: Some(parameters),
1880                ..Default::default()
1881            })
1882        }
1883    }
1884    #[derive(Debug, FromParameters)]
1885    pub struct Output {
1886        #[parameter_rename = "return"]
1887        pub return_: ValueSet,
1888    }
1889    impl From<Output> for Resource {
1890        fn from(value: Output) -> Self {
1891            Resource::ValueSet(value.return_)
1892        }
1893    }
1894}
1895pub mod ValueSetValidateCode {
1896    use super::*;
1897    pub const CODE: &str = "validate-code";
1898    #[derive(Debug, FromParameters, ToParameters)]
1899    pub struct Input {
1900        pub url: Option<FHIRUri>,
1901        pub context: Option<FHIRUri>,
1902        pub valueSet: Option<ValueSet>,
1903        pub valueSetVersion: Option<FHIRString>,
1904        pub code: Option<FHIRCode>,
1905        pub system: Option<FHIRUri>,
1906        pub systemVersion: Option<FHIRString>,
1907        pub display: Option<FHIRString>,
1908        pub coding: Option<Coding>,
1909        pub codeableConcept: Option<CodeableConcept>,
1910        pub date: Option<FHIRDateTime>,
1911        #[parameter_rename = "abstract"]
1912        pub abstract_: Option<FHIRBoolean>,
1913        pub displayLanguage: Option<FHIRCode>,
1914    }
1915    impl From<Input> for Resource {
1916        fn from(value: Input) -> Self {
1917            let parameters: Vec<ParametersParameter> = value.into();
1918            Resource::Parameters(Parameters {
1919                parameter: Some(parameters),
1920                ..Default::default()
1921            })
1922        }
1923    }
1924    #[derive(Debug, FromParameters, ToParameters)]
1925    pub struct Output {
1926        pub result: FHIRBoolean,
1927        pub message: Option<FHIRString>,
1928        pub display: Option<FHIRString>,
1929    }
1930    impl From<Output> for Resource {
1931        fn from(value: Output) -> Self {
1932            let parameters: Vec<ParametersParameter> = value.into();
1933            Resource::Parameters(Parameters {
1934                parameter: Some(parameters),
1935                ..Default::default()
1936            })
1937        }
1938    }
1939}
haste_fhir_generated_ops/generated.rs

haste_fhir_generated_ops/
generated.rs
