openshift_openapi/v4_5/api/user/v1/
identity.rs

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

openshift_openapi/v4_5/api/user/v1/
identity.rs
