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

haste_fhir_generated_ops/
generated.rs
