openshift_openapi/v4_5/api/authorization/v1/
role.rs

1// Generated from definition com.github.openshift.api.authorization.v1.Role
2
3/// Role is a logical grouping of PolicyRules that can be referenced as a unit by RoleBindings.
4#[derive(Clone, Debug, Default, PartialEq)]
5pub struct Role {
6    /// Standard object's metadata.
7    pub metadata: k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta,
8
9    /// Rules holds all the PolicyRules for this Role
10    pub rules: Vec<crate::api::authorization::v1::PolicyRule>,
11}
12
13// Begin authorization.openshift.io/v1/Role
14
15// Generated from operation createAuthorizationOpenshiftIoV1NamespacedRole
16
17impl Role {
18    /// create a Role
19    ///
20    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::CreateResponse`]`<Self>>` constructor, or [`k8s_openapi::CreateResponse`]`<Self>` directly, to parse the HTTP response.
21    ///
22    /// # Arguments
23    ///
24    /// * `namespace`
25    ///
26    ///     object name and auth scope, such as for teams and projects
27    ///
28    /// * `body`
29    ///
30    /// * `optional`
31    ///
32    ///     Optional parameters. Use `Default::default()` to not pass any.
33    #[cfg(feature = "api")]
34    pub fn create_namespaced_role(
35        namespace: &str,
36        body: &crate::api::authorization::v1::Role,
37        optional: k8s_openapi::CreateOptional<'_>,
38    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::CreateResponse<Self>>), k8s_openapi::RequestError> {
39        let __url = format!("/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles?",
40            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
41        );
42        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
43        optional.__serialize(&mut __query_pairs);
44        let __url = __query_pairs.finish();
45
46        let __request = http::Request::post(__url);
47        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
48        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
49        match __request.body(__body) {
50            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
51            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
52        }
53    }
54}
55
56// Generated from operation deleteAuthorizationOpenshiftIoV1NamespacedRole
57
58impl Role {
59    /// delete a Role
60    ///
61    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::DeleteResponse`]`<Self>>` constructor, or [`k8s_openapi::DeleteResponse`]`<Self>` directly, to parse the HTTP response.
62    ///
63    /// # Arguments
64    ///
65    /// * `name`
66    ///
67    ///     name of the Role
68    ///
69    /// * `namespace`
70    ///
71    ///     object name and auth scope, such as for teams and projects
72    ///
73    /// * `optional`
74    ///
75    ///     Optional parameters. Use `Default::default()` to not pass any.
76    #[cfg(feature = "api")]
77    pub fn delete_namespaced_role(
78        name: &str,
79        namespace: &str,
80        optional: k8s_openapi::DeleteOptional<'_>,
81    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::DeleteResponse<Self>>), k8s_openapi::RequestError> {
82        let __url = format!("/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}",
83            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
84            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
85        );
86
87        let __request = http::Request::delete(__url);
88        let __body = serde_json::to_vec(&optional).map_err(k8s_openapi::RequestError::Json)?;
89        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
90        match __request.body(__body) {
91            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
92            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
93        }
94    }
95}
96
97// Generated from operation listAuthorizationOpenshiftIoV1NamespacedRole
98
99impl Role {
100    /// list objects of kind Role
101    ///
102    /// This operation only supports listing all items of this type.
103    ///
104    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ListResponse`]`<Self>>` constructor, or [`k8s_openapi::ListResponse`]`<Self>` directly, to parse the HTTP response.
105    ///
106    /// # Arguments
107    ///
108    /// * `namespace`
109    ///
110    ///     object name and auth scope, such as for teams and projects
111    ///
112    /// * `optional`
113    ///
114    ///     Optional parameters. Use `Default::default()` to not pass any.
115    #[cfg(feature = "api")]
116    pub fn list_namespaced_role(
117        namespace: &str,
118        optional: k8s_openapi::ListOptional<'_>,
119    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ListResponse<Self>>), k8s_openapi::RequestError> {
120        let __url = format!("/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles?",
121            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
122        );
123        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
124        optional.__serialize(&mut __query_pairs);
125        let __url = __query_pairs.finish();
126
127        let __request = http::Request::get(__url);
128        let __body = vec![];
129        match __request.body(__body) {
130            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
131            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
132        }
133    }
134}
135
136// Generated from operation listAuthorizationOpenshiftIoV1RoleForAllNamespaces
137
138impl Role {
139    /// list objects of kind Role
140    ///
141    /// This operation only supports listing all items of this type.
142    ///
143    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ListResponse`]`<Self>>` constructor, or [`k8s_openapi::ListResponse`]`<Self>` directly, to parse the HTTP response.
144    ///
145    /// # Arguments
146    ///
147    /// * `optional`
148    ///
149    ///     Optional parameters. Use `Default::default()` to not pass any.
150    #[cfg(feature = "api")]
151    pub fn list_role_for_all_namespaces(
152        optional: k8s_openapi::ListOptional<'_>,
153    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ListResponse<Self>>), k8s_openapi::RequestError> {
154        let __url = "/apis/authorization.openshift.io/v1/roles?".to_owned();
155        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
156        optional.__serialize(&mut __query_pairs);
157        let __url = __query_pairs.finish();
158
159        let __request = http::Request::get(__url);
160        let __body = vec![];
161        match __request.body(__body) {
162            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
163            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
164        }
165    }
166}
167
168// Generated from operation patchAuthorizationOpenshiftIoV1NamespacedRole
169
170impl Role {
171    /// partially update the specified Role
172    ///
173    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::PatchResponse`]`<Self>>` constructor, or [`k8s_openapi::PatchResponse`]`<Self>` directly, to parse the HTTP response.
174    ///
175    /// # Arguments
176    ///
177    /// * `name`
178    ///
179    ///     name of the Role
180    ///
181    /// * `namespace`
182    ///
183    ///     object name and auth scope, such as for teams and projects
184    ///
185    /// * `body`
186    ///
187    /// * `optional`
188    ///
189    ///     Optional parameters. Use `Default::default()` to not pass any.
190    #[cfg(feature = "api")]
191    pub fn patch_namespaced_role(
192        name: &str,
193        namespace: &str,
194        body: &k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch,
195        optional: k8s_openapi::PatchOptional<'_>,
196    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::PatchResponse<Self>>), k8s_openapi::RequestError> {
197        let __url = format!("/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}?",
198            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
199            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
200        );
201        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
202        optional.__serialize(&mut __query_pairs);
203        let __url = __query_pairs.finish();
204
205        let __request = http::Request::patch(__url);
206        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
207        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static(match body {
208            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::Json(_) => "application/json-patch+json",
209            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::Merge(_) => "application/merge-patch+json",
210            k8s_openapi::apimachinery::pkg::apis::meta::v1::Patch::StrategicMerge(_) => "application/strategic-merge-patch+json",
211        }));
212        match __request.body(__body) {
213            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
214            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
215        }
216    }
217}
218
219// Generated from operation readAuthorizationOpenshiftIoV1NamespacedRole
220
221impl Role {
222    /// read the specified Role
223    ///
224    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`ReadNamespacedRoleResponse`]`>` constructor, or [`ReadNamespacedRoleResponse`] directly, to parse the HTTP response.
225    ///
226    /// # Arguments
227    ///
228    /// * `name`
229    ///
230    ///     name of the Role
231    ///
232    /// * `namespace`
233    ///
234    ///     object name and auth scope, such as for teams and projects
235    ///
236    /// * `optional`
237    ///
238    ///     Optional parameters. Use `Default::default()` to not pass any.
239    #[cfg(feature = "api")]
240    pub fn read_namespaced_role(
241        name: &str,
242        namespace: &str,
243        optional: ReadNamespacedRoleOptional<'_>,
244    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<ReadNamespacedRoleResponse>), k8s_openapi::RequestError> {
245        let ReadNamespacedRoleOptional {
246            pretty,
247        } = optional;
248        let __url = format!("/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}?",
249            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
250            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
251        );
252        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
253        if let Some(pretty) = pretty {
254            __query_pairs.append_pair("pretty", pretty);
255        }
256        let __url = __query_pairs.finish();
257
258        let __request = http::Request::get(__url);
259        let __body = vec![];
260        match __request.body(__body) {
261            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
262            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
263        }
264    }
265}
266
267/// Optional parameters of [`Role::read_namespaced_role`]
268#[cfg(feature = "api")]
269#[derive(Clone, Copy, Debug, Default)]
270pub struct ReadNamespacedRoleOptional<'a> {
271    /// If 'true', then the output is pretty printed.
272    pub pretty: Option<&'a str>,
273}
274
275/// Use `<ReadNamespacedRoleResponse as Response>::try_from_parts` to parse the HTTP response body of [`Role::read_namespaced_role`]
276#[cfg(feature = "api")]
277#[derive(Debug)]
278pub enum ReadNamespacedRoleResponse {
279    Ok(crate::api::authorization::v1::Role),
280    Other(Result<Option<serde_json::Value>, serde_json::Error>),
281}
282
283#[cfg(feature = "api")]
284impl k8s_openapi::Response for ReadNamespacedRoleResponse {
285    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
286        match status_code {
287            http::StatusCode::OK => {
288                let result = match serde_json::from_slice(buf) {
289                    Ok(value) => value,
290                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
291                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
292                };
293                Ok((ReadNamespacedRoleResponse::Ok(result), buf.len()))
294            },
295            _ => {
296                let (result, read) =
297                    if buf.is_empty() {
298                        (Ok(None), 0)
299                    }
300                    else {
301                        match serde_json::from_slice(buf) {
302                            Ok(value) => (Ok(Some(value)), buf.len()),
303                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
304                            Err(err) => (Err(err), 0),
305                        }
306                    };
307                Ok((ReadNamespacedRoleResponse::Other(result), read))
308            },
309        }
310    }
311}
312
313// Generated from operation replaceAuthorizationOpenshiftIoV1NamespacedRole
314
315impl Role {
316    /// replace the specified Role
317    ///
318    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::ReplaceResponse`]`<Self>>` constructor, or [`k8s_openapi::ReplaceResponse`]`<Self>` directly, to parse the HTTP response.
319    ///
320    /// # Arguments
321    ///
322    /// * `name`
323    ///
324    ///     name of the Role
325    ///
326    /// * `namespace`
327    ///
328    ///     object name and auth scope, such as for teams and projects
329    ///
330    /// * `body`
331    ///
332    /// * `optional`
333    ///
334    ///     Optional parameters. Use `Default::default()` to not pass any.
335    #[cfg(feature = "api")]
336    pub fn replace_namespaced_role(
337        name: &str,
338        namespace: &str,
339        body: &crate::api::authorization::v1::Role,
340        optional: k8s_openapi::ReplaceOptional<'_>,
341    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::ReplaceResponse<Self>>), k8s_openapi::RequestError> {
342        let __url = format!("/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles/{name}?",
343            name = k8s_openapi::percent_encoding::percent_encode(name.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
344            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
345        );
346        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
347        optional.__serialize(&mut __query_pairs);
348        let __url = __query_pairs.finish();
349
350        let __request = http::Request::put(__url);
351        let __body = serde_json::to_vec(body).map_err(k8s_openapi::RequestError::Json)?;
352        let __request = __request.header(http::header::CONTENT_TYPE, http::header::HeaderValue::from_static("application/json"));
353        match __request.body(__body) {
354            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
355            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
356        }
357    }
358}
359
360// Generated from operation watchAuthorizationOpenshiftIoV1NamespacedRole
361
362impl Role {
363    /// list objects of kind Role
364    ///
365    /// This operation only supports watching one item, or a list of items, of this type for changes.
366    ///
367    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::WatchResponse`]`<Self>>` constructor, or [`k8s_openapi::WatchResponse`]`<Self>` directly, to parse the HTTP response.
368    ///
369    /// # Arguments
370    ///
371    /// * `namespace`
372    ///
373    ///     object name and auth scope, such as for teams and projects
374    ///
375    /// * `optional`
376    ///
377    ///     Optional parameters. Use `Default::default()` to not pass any.
378    #[cfg(feature = "api")]
379    pub fn watch_namespaced_role(
380        namespace: &str,
381        optional: k8s_openapi::WatchOptional<'_>,
382    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::WatchResponse<Self>>), k8s_openapi::RequestError> {
383        let __url = format!("/apis/authorization.openshift.io/v1/namespaces/{namespace}/roles?",
384            namespace = k8s_openapi::percent_encoding::percent_encode(namespace.as_bytes(), k8s_openapi::percent_encoding2::PATH_SEGMENT_ENCODE_SET),
385        );
386        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
387        optional.__serialize(&mut __query_pairs);
388        let __url = __query_pairs.finish();
389
390        let __request = http::Request::get(__url);
391        let __body = vec![];
392        match __request.body(__body) {
393            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
394            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
395        }
396    }
397}
398
399// Generated from operation watchAuthorizationOpenshiftIoV1RoleForAllNamespaces
400
401impl Role {
402    /// list objects of kind Role
403    ///
404    /// This operation only supports watching one item, or a list of items, of this type for changes.
405    ///
406    /// Use the returned [`k8s_openapi::ResponseBody`]`<`[`k8s_openapi::WatchResponse`]`<Self>>` constructor, or [`k8s_openapi::WatchResponse`]`<Self>` directly, to parse the HTTP response.
407    ///
408    /// # Arguments
409    ///
410    /// * `optional`
411    ///
412    ///     Optional parameters. Use `Default::default()` to not pass any.
413    #[cfg(feature = "api")]
414    pub fn watch_role_for_all_namespaces(
415        optional: k8s_openapi::WatchOptional<'_>,
416    ) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<k8s_openapi::WatchResponse<Self>>), k8s_openapi::RequestError> {
417        let __url = "/apis/authorization.openshift.io/v1/roles?".to_owned();
418        let mut __query_pairs = k8s_openapi::url::form_urlencoded::Serializer::new(__url);
419        optional.__serialize(&mut __query_pairs);
420        let __url = __query_pairs.finish();
421
422        let __request = http::Request::get(__url);
423        let __body = vec![];
424        match __request.body(__body) {
425            Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
426            Err(err) => Err(k8s_openapi::RequestError::Http(err)),
427        }
428    }
429}
430
431// End authorization.openshift.io/v1/Role
432
433impl k8s_openapi::Resource for Role {
434    const API_VERSION: &'static str = "authorization.openshift.io/v1";
435    const GROUP: &'static str = "authorization.openshift.io";
436    const KIND: &'static str = "Role";
437    const VERSION: &'static str = "v1";
438}
439
440impl k8s_openapi::ListableResource for Role {
441    const LIST_KIND: &'static str = concat!("Role", "List");
442}
443
444impl k8s_openapi::Metadata for Role {
445    type Ty = k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
446
447    fn metadata(&self) -> &<Self as k8s_openapi::Metadata>::Ty {
448        &self.metadata
449    }
450
451    fn metadata_mut(&mut self) -> &mut<Self as k8s_openapi::Metadata>::Ty {
452        &mut self.metadata
453    }
454}
455
456impl<'de> serde::Deserialize<'de> for Role {
457    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
458        #[allow(non_camel_case_types)]
459        enum Field {
460            Key_api_version,
461            Key_kind,
462            Key_metadata,
463            Key_rules,
464            Other,
465        }
466
467        impl<'de> serde::Deserialize<'de> for Field {
468            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
469                struct Visitor;
470
471                impl<'de> serde::de::Visitor<'de> for Visitor {
472                    type Value = Field;
473
474                    fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
475                        f.write_str("field identifier")
476                    }
477
478                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> where E: serde::de::Error {
479                        Ok(match v {
480                            "apiVersion" => Field::Key_api_version,
481                            "kind" => Field::Key_kind,
482                            "metadata" => Field::Key_metadata,
483                            "rules" => Field::Key_rules,
484                            _ => Field::Other,
485                        })
486                    }
487                }
488
489                deserializer.deserialize_identifier(Visitor)
490            }
491        }
492
493        struct Visitor;
494
495        impl<'de> serde::de::Visitor<'de> for Visitor {
496            type Value = Role;
497
498            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
499                f.write_str(<Self::Value as k8s_openapi::Resource>::KIND)
500            }
501
502            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error> where A: serde::de::MapAccess<'de> {
503                let mut value_metadata: Option<k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta> = None;
504                let mut value_rules: Option<Vec<crate::api::authorization::v1::PolicyRule>> = None;
505
506                while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
507                    match key {
508                        Field::Key_api_version => {
509                            let value_api_version: String = serde::de::MapAccess::next_value(&mut map)?;
510                            if value_api_version != <Self::Value as k8s_openapi::Resource>::API_VERSION {
511                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_api_version), &<Self::Value as k8s_openapi::Resource>::API_VERSION));
512                            }
513                        },
514                        Field::Key_kind => {
515                            let value_kind: String = serde::de::MapAccess::next_value(&mut map)?;
516                            if value_kind != <Self::Value as k8s_openapi::Resource>::KIND {
517                                return Err(serde::de::Error::invalid_value(serde::de::Unexpected::Str(&value_kind), &<Self::Value as k8s_openapi::Resource>::KIND));
518                            }
519                        },
520                        Field::Key_metadata => value_metadata = Some(serde::de::MapAccess::next_value(&mut map)?),
521                        Field::Key_rules => value_rules = Some(serde::de::MapAccess::next_value(&mut map)?),
522                        Field::Other => { let _: serde::de::IgnoredAny = serde::de::MapAccess::next_value(&mut map)?; },
523                    }
524                }
525
526                Ok(Role {
527                    metadata: value_metadata.ok_or_else(|| serde::de::Error::missing_field("metadata"))?,
528                    rules: value_rules.ok_or_else(|| serde::de::Error::missing_field("rules"))?,
529                })
530            }
531        }
532
533        deserializer.deserialize_struct(
534            <Self as k8s_openapi::Resource>::KIND,
535            &[
536                "apiVersion",
537                "kind",
538                "metadata",
539                "rules",
540            ],
541            Visitor,
542        )
543    }
544}
545
546impl serde::Serialize for Role {
547    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
548        let mut state = serializer.serialize_struct(
549            <Self as k8s_openapi::Resource>::KIND,
550            4,
551        )?;
552        serde::ser::SerializeStruct::serialize_field(&mut state, "apiVersion", <Self as k8s_openapi::Resource>::API_VERSION)?;
553        serde::ser::SerializeStruct::serialize_field(&mut state, "kind", <Self as k8s_openapi::Resource>::KIND)?;
554        serde::ser::SerializeStruct::serialize_field(&mut state, "metadata", &self.metadata)?;
555        serde::ser::SerializeStruct::serialize_field(&mut state, "rules", &self.rules)?;
556        serde::ser::SerializeStruct::end(state)
557    }
558}
openshift_openapi/v4_5/api/authorization/v1/role.rs

openshift_openapi/v4_5/api/authorization/v1/
role.rs
