1pub mod argoproj_io {
5 pub mod v1alpha1 {
6 pub mod event_bus {
7 #[derive(serde::Deserialize, Debug, PartialEq)]
8 pub struct EventBus {
9 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
10 pub spec: Spec,
11 pub status: Status,
12 }
13
14 impl k8s_openapi::Resource for EventBus {
15 type Scope = k8s_openapi::ClusterResourceScope;
16
17 const API_VERSION: &'static str = "argoproj.io/v1alpha1";
18 const GROUP: &'static str = "argoproj.io";
19 const KIND: &'static str = "EventBus";
20 const VERSION: &'static str = "v1alpha1";
21 const URL_PATH_SEGMENT: &'static str = "";
22 }
23
24 impl k8s_openapi::Metadata for EventBus {
25 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
26
27 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
28 &self.metadata
29 }
30
31 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
32 &mut self.metadata
33 }
34 }
35
36 impl serde::Serialize for EventBus {
37 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
38 where
39 S: serde::Serializer,
40 {
41 use serde::ser::SerializeStruct;
42 let mut state = serializer.serialize_struct("EventBus", 5)?;
43 state.serialize_field(
44 "apiVersion",
45 <Self as k8s_openapi::Resource>::API_VERSION,
46 )?;
47 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
48 state.serialize_field("metadata", &self.metadata)?;
49 state.serialize_field("spec", &self.spec)?;
50 state.serialize_field("status", &self.status)?;
51 state.end()
52 }
53 }
54
55 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
56 #[serde(rename_all = "camelCase")]
57 pub struct Spec {
58 pub properties: serde_json::Map<String, serde_json::Value>,
59 }
60
61 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
62 #[serde(rename_all = "camelCase")]
63 pub struct Status {
64 pub properties: serde_json::Map<String, serde_json::Value>,
65 }
66 }
67 pub mod event_source {
68 #[derive(serde::Deserialize, Debug, PartialEq)]
69 pub struct EventSource {
70 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
71 pub spec: Spec,
72 pub status: Status,
73 }
74
75 impl k8s_openapi::Resource for EventSource {
76 type Scope = k8s_openapi::ClusterResourceScope;
77
78 const API_VERSION: &'static str = "argoproj.io/v1alpha1";
79 const GROUP: &'static str = "argoproj.io";
80 const KIND: &'static str = "EventSource";
81 const VERSION: &'static str = "v1alpha1";
82 const URL_PATH_SEGMENT: &'static str = "";
83 }
84
85 impl k8s_openapi::Metadata for EventSource {
86 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
87
88 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
89 &self.metadata
90 }
91
92 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
93 &mut self.metadata
94 }
95 }
96
97 impl serde::Serialize for EventSource {
98 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
99 where
100 S: serde::Serializer,
101 {
102 use serde::ser::SerializeStruct;
103 let mut state = serializer.serialize_struct("EventSource", 5)?;
104 state.serialize_field(
105 "apiVersion",
106 <Self as k8s_openapi::Resource>::API_VERSION,
107 )?;
108 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
109 state.serialize_field("metadata", &self.metadata)?;
110 state.serialize_field("spec", &self.spec)?;
111 state.serialize_field("status", &self.status)?;
112 state.end()
113 }
114 }
115
116 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
117 #[serde(rename_all = "camelCase")]
118 pub struct Spec {
119 pub properties: serde_json::Map<String, serde_json::Value>,
120 }
121
122 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
123 #[serde(rename_all = "camelCase")]
124 pub struct Status {
125 pub properties: serde_json::Map<String, serde_json::Value>,
126 }
127 }
128 pub mod sensor {
129 #[derive(serde::Deserialize, Debug, PartialEq)]
130 pub struct Sensor {
131 pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
132 pub spec: Spec,
133 pub status: Status,
134 }
135
136 impl k8s_openapi::Resource for Sensor {
137 type Scope = k8s_openapi::ClusterResourceScope;
138
139 const API_VERSION: &'static str = "argoproj.io/v1alpha1";
140 const GROUP: &'static str = "argoproj.io";
141 const KIND: &'static str = "Sensor";
142 const VERSION: &'static str = "v1alpha1";
143 const URL_PATH_SEGMENT: &'static str = "";
144 }
145
146 impl k8s_openapi::Metadata for Sensor {
147 type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
148
149 fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
150 &self.metadata
151 }
152
153 fn metadata_mut(&mut self) -> &mut <Self as k8s_openapi::Metadata>::Ty {
154 &mut self.metadata
155 }
156 }
157
158 impl serde::Serialize for Sensor {
159 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
160 where
161 S: serde::Serializer,
162 {
163 use serde::ser::SerializeStruct;
164 let mut state = serializer.serialize_struct("Sensor", 5)?;
165 state.serialize_field(
166 "apiVersion",
167 <Self as k8s_openapi::Resource>::API_VERSION,
168 )?;
169 state.serialize_field("kind", <Self as k8s_openapi::Resource>::KIND)?;
170 state.serialize_field("metadata", &self.metadata)?;
171 state.serialize_field("spec", &self.spec)?;
172 state.serialize_field("status", &self.status)?;
173 state.end()
174 }
175 }
176
177 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
178 #[serde(rename_all = "camelCase")]
179 pub struct Spec {
180 pub properties: serde_json::Map<String, serde_json::Value>,
181 }
182
183 #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
184 #[serde(rename_all = "camelCase")]
185 pub struct Status {
186 pub properties: serde_json::Map<String, serde_json::Value>,
187 }
188 }
189 }
190}