openshift_openapi/v4_5/
mod.rs

1pub mod api;
2
3// Generated from operation getAppsOpenshiftIoAPIGroup
4
5/// get information of a group
6///
7/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetAppsOpenshiftIoAPIGroupResponse`]`>` constructor, or [`GetAppsOpenshiftIoAPIGroupResponse`] directly, to parse the HTTP response.
8#[cfg(feature = "api")]
9pub fn get_apps_openshift_io_api_group(
10) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetAppsOpenshiftIoAPIGroupResponse>), k8s_openapi::RequestError> {
11    let __url = "/apis/apps.openshift.io/".to_owned();
12
13    let __request = http::Request::get(__url);
14    let __body = vec![];
15    match __request.body(__body) {
16        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
17        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
18    }
19}
20
21/// Use `<GetAppsOpenshiftIoAPIGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_apps_openshift_io_api_group`]
22#[cfg(feature = "api")]
23#[derive(Debug)]
24pub enum GetAppsOpenshiftIoAPIGroupResponse {
25    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIGroup),
26    Other(Result<Option<serde_json::Value>, serde_json::Error>),
27}
28
29#[cfg(feature = "api")]
30impl k8s_openapi::Response for GetAppsOpenshiftIoAPIGroupResponse {
31    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
32        match status_code {
33            http::StatusCode::OK => {
34                let result = match serde_json::from_slice(buf) {
35                    Ok(value) => value,
36                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
37                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
38                };
39                Ok((GetAppsOpenshiftIoAPIGroupResponse::Ok(result), buf.len()))
40            },
41            _ => {
42                let (result, read) =
43                    if buf.is_empty() {
44                        (Ok(None), 0)
45                    }
46                    else {
47                        match serde_json::from_slice(buf) {
48                            Ok(value) => (Ok(Some(value)), buf.len()),
49                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
50                            Err(err) => (Err(err), 0),
51                        }
52                    };
53                Ok((GetAppsOpenshiftIoAPIGroupResponse::Other(result), read))
54            },
55        }
56    }
57}
58
59// Generated from operation getAppsOpenshiftIoV1APIResources
60
61/// get available resources
62///
63/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetAppsOpenshiftIoV1APIResourcesResponse`]`>` constructor, or [`GetAppsOpenshiftIoV1APIResourcesResponse`] directly, to parse the HTTP response.
64#[cfg(feature = "api")]
65pub fn get_apps_openshift_io_v1_api_resources(
66) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetAppsOpenshiftIoV1APIResourcesResponse>), k8s_openapi::RequestError> {
67    let __url = "/apis/apps.openshift.io/v1/".to_owned();
68
69    let __request = http::Request::get(__url);
70    let __body = vec![];
71    match __request.body(__body) {
72        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
73        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
74    }
75}
76
77/// Use `<GetAppsOpenshiftIoV1APIResourcesResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_apps_openshift_io_v1_api_resources`]
78#[cfg(feature = "api")]
79#[derive(Debug)]
80pub enum GetAppsOpenshiftIoV1APIResourcesResponse {
81    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIResourceList),
82    Other(Result<Option<serde_json::Value>, serde_json::Error>),
83}
84
85#[cfg(feature = "api")]
86impl k8s_openapi::Response for GetAppsOpenshiftIoV1APIResourcesResponse {
87    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
88        match status_code {
89            http::StatusCode::OK => {
90                let result = match serde_json::from_slice(buf) {
91                    Ok(value) => value,
92                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
93                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
94                };
95                Ok((GetAppsOpenshiftIoV1APIResourcesResponse::Ok(result), buf.len()))
96            },
97            _ => {
98                let (result, read) =
99                    if buf.is_empty() {
100                        (Ok(None), 0)
101                    }
102                    else {
103                        match serde_json::from_slice(buf) {
104                            Ok(value) => (Ok(Some(value)), buf.len()),
105                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
106                            Err(err) => (Err(err), 0),
107                        }
108                    };
109                Ok((GetAppsOpenshiftIoV1APIResourcesResponse::Other(result), read))
110            },
111        }
112    }
113}
114
115// Generated from operation getAuthorizationOpenshiftIoAPIGroup
116
117/// get information of a group
118///
119/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetAuthorizationOpenshiftIoAPIGroupResponse`]`>` constructor, or [`GetAuthorizationOpenshiftIoAPIGroupResponse`] directly, to parse the HTTP response.
120#[cfg(feature = "api")]
121pub fn get_authorization_openshift_io_api_group(
122) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetAuthorizationOpenshiftIoAPIGroupResponse>), k8s_openapi::RequestError> {
123    let __url = "/apis/authorization.openshift.io/".to_owned();
124
125    let __request = http::Request::get(__url);
126    let __body = vec![];
127    match __request.body(__body) {
128        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
129        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
130    }
131}
132
133/// Use `<GetAuthorizationOpenshiftIoAPIGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_authorization_openshift_io_api_group`]
134#[cfg(feature = "api")]
135#[derive(Debug)]
136pub enum GetAuthorizationOpenshiftIoAPIGroupResponse {
137    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIGroup),
138    Other(Result<Option<serde_json::Value>, serde_json::Error>),
139}
140
141#[cfg(feature = "api")]
142impl k8s_openapi::Response for GetAuthorizationOpenshiftIoAPIGroupResponse {
143    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
144        match status_code {
145            http::StatusCode::OK => {
146                let result = match serde_json::from_slice(buf) {
147                    Ok(value) => value,
148                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
149                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
150                };
151                Ok((GetAuthorizationOpenshiftIoAPIGroupResponse::Ok(result), buf.len()))
152            },
153            _ => {
154                let (result, read) =
155                    if buf.is_empty() {
156                        (Ok(None), 0)
157                    }
158                    else {
159                        match serde_json::from_slice(buf) {
160                            Ok(value) => (Ok(Some(value)), buf.len()),
161                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
162                            Err(err) => (Err(err), 0),
163                        }
164                    };
165                Ok((GetAuthorizationOpenshiftIoAPIGroupResponse::Other(result), read))
166            },
167        }
168    }
169}
170
171// Generated from operation getAuthorizationOpenshiftIoV1APIResources
172
173/// get available resources
174///
175/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetAuthorizationOpenshiftIoV1APIResourcesResponse`]`>` constructor, or [`GetAuthorizationOpenshiftIoV1APIResourcesResponse`] directly, to parse the HTTP response.
176#[cfg(feature = "api")]
177pub fn get_authorization_openshift_io_v1_api_resources(
178) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetAuthorizationOpenshiftIoV1APIResourcesResponse>), k8s_openapi::RequestError> {
179    let __url = "/apis/authorization.openshift.io/v1/".to_owned();
180
181    let __request = http::Request::get(__url);
182    let __body = vec![];
183    match __request.body(__body) {
184        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
185        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
186    }
187}
188
189/// Use `<GetAuthorizationOpenshiftIoV1APIResourcesResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_authorization_openshift_io_v1_api_resources`]
190#[cfg(feature = "api")]
191#[derive(Debug)]
192pub enum GetAuthorizationOpenshiftIoV1APIResourcesResponse {
193    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIResourceList),
194    Other(Result<Option<serde_json::Value>, serde_json::Error>),
195}
196
197#[cfg(feature = "api")]
198impl k8s_openapi::Response for GetAuthorizationOpenshiftIoV1APIResourcesResponse {
199    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
200        match status_code {
201            http::StatusCode::OK => {
202                let result = match serde_json::from_slice(buf) {
203                    Ok(value) => value,
204                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
205                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
206                };
207                Ok((GetAuthorizationOpenshiftIoV1APIResourcesResponse::Ok(result), buf.len()))
208            },
209            _ => {
210                let (result, read) =
211                    if buf.is_empty() {
212                        (Ok(None), 0)
213                    }
214                    else {
215                        match serde_json::from_slice(buf) {
216                            Ok(value) => (Ok(Some(value)), buf.len()),
217                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
218                            Err(err) => (Err(err), 0),
219                        }
220                    };
221                Ok((GetAuthorizationOpenshiftIoV1APIResourcesResponse::Other(result), read))
222            },
223        }
224    }
225}
226
227// Generated from operation getBuildOpenshiftIoAPIGroup
228
229/// get information of a group
230///
231/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetBuildOpenshiftIoAPIGroupResponse`]`>` constructor, or [`GetBuildOpenshiftIoAPIGroupResponse`] directly, to parse the HTTP response.
232#[cfg(feature = "api")]
233pub fn get_build_openshift_io_api_group(
234) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetBuildOpenshiftIoAPIGroupResponse>), k8s_openapi::RequestError> {
235    let __url = "/apis/build.openshift.io/".to_owned();
236
237    let __request = http::Request::get(__url);
238    let __body = vec![];
239    match __request.body(__body) {
240        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
241        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
242    }
243}
244
245/// Use `<GetBuildOpenshiftIoAPIGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_build_openshift_io_api_group`]
246#[cfg(feature = "api")]
247#[derive(Debug)]
248pub enum GetBuildOpenshiftIoAPIGroupResponse {
249    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIGroup),
250    Other(Result<Option<serde_json::Value>, serde_json::Error>),
251}
252
253#[cfg(feature = "api")]
254impl k8s_openapi::Response for GetBuildOpenshiftIoAPIGroupResponse {
255    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
256        match status_code {
257            http::StatusCode::OK => {
258                let result = match serde_json::from_slice(buf) {
259                    Ok(value) => value,
260                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
261                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
262                };
263                Ok((GetBuildOpenshiftIoAPIGroupResponse::Ok(result), buf.len()))
264            },
265            _ => {
266                let (result, read) =
267                    if buf.is_empty() {
268                        (Ok(None), 0)
269                    }
270                    else {
271                        match serde_json::from_slice(buf) {
272                            Ok(value) => (Ok(Some(value)), buf.len()),
273                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
274                            Err(err) => (Err(err), 0),
275                        }
276                    };
277                Ok((GetBuildOpenshiftIoAPIGroupResponse::Other(result), read))
278            },
279        }
280    }
281}
282
283// Generated from operation getBuildOpenshiftIoV1APIResources
284
285/// get available resources
286///
287/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetBuildOpenshiftIoV1APIResourcesResponse`]`>` constructor, or [`GetBuildOpenshiftIoV1APIResourcesResponse`] directly, to parse the HTTP response.
288#[cfg(feature = "api")]
289pub fn get_build_openshift_io_v1_api_resources(
290) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetBuildOpenshiftIoV1APIResourcesResponse>), k8s_openapi::RequestError> {
291    let __url = "/apis/build.openshift.io/v1/".to_owned();
292
293    let __request = http::Request::get(__url);
294    let __body = vec![];
295    match __request.body(__body) {
296        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
297        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
298    }
299}
300
301/// Use `<GetBuildOpenshiftIoV1APIResourcesResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_build_openshift_io_v1_api_resources`]
302#[cfg(feature = "api")]
303#[derive(Debug)]
304pub enum GetBuildOpenshiftIoV1APIResourcesResponse {
305    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIResourceList),
306    Other(Result<Option<serde_json::Value>, serde_json::Error>),
307}
308
309#[cfg(feature = "api")]
310impl k8s_openapi::Response for GetBuildOpenshiftIoV1APIResourcesResponse {
311    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
312        match status_code {
313            http::StatusCode::OK => {
314                let result = match serde_json::from_slice(buf) {
315                    Ok(value) => value,
316                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
317                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
318                };
319                Ok((GetBuildOpenshiftIoV1APIResourcesResponse::Ok(result), buf.len()))
320            },
321            _ => {
322                let (result, read) =
323                    if buf.is_empty() {
324                        (Ok(None), 0)
325                    }
326                    else {
327                        match serde_json::from_slice(buf) {
328                            Ok(value) => (Ok(Some(value)), buf.len()),
329                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
330                            Err(err) => (Err(err), 0),
331                        }
332                    };
333                Ok((GetBuildOpenshiftIoV1APIResourcesResponse::Other(result), read))
334            },
335        }
336    }
337}
338
339// Generated from operation getImageOpenshiftIoAPIGroup
340
341/// get information of a group
342///
343/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetImageOpenshiftIoAPIGroupResponse`]`>` constructor, or [`GetImageOpenshiftIoAPIGroupResponse`] directly, to parse the HTTP response.
344#[cfg(feature = "api")]
345pub fn get_image_openshift_io_api_group(
346) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetImageOpenshiftIoAPIGroupResponse>), k8s_openapi::RequestError> {
347    let __url = "/apis/image.openshift.io/".to_owned();
348
349    let __request = http::Request::get(__url);
350    let __body = vec![];
351    match __request.body(__body) {
352        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
353        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
354    }
355}
356
357/// Use `<GetImageOpenshiftIoAPIGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_image_openshift_io_api_group`]
358#[cfg(feature = "api")]
359#[derive(Debug)]
360pub enum GetImageOpenshiftIoAPIGroupResponse {
361    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIGroup),
362    Other(Result<Option<serde_json::Value>, serde_json::Error>),
363}
364
365#[cfg(feature = "api")]
366impl k8s_openapi::Response for GetImageOpenshiftIoAPIGroupResponse {
367    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
368        match status_code {
369            http::StatusCode::OK => {
370                let result = match serde_json::from_slice(buf) {
371                    Ok(value) => value,
372                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
373                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
374                };
375                Ok((GetImageOpenshiftIoAPIGroupResponse::Ok(result), buf.len()))
376            },
377            _ => {
378                let (result, read) =
379                    if buf.is_empty() {
380                        (Ok(None), 0)
381                    }
382                    else {
383                        match serde_json::from_slice(buf) {
384                            Ok(value) => (Ok(Some(value)), buf.len()),
385                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
386                            Err(err) => (Err(err), 0),
387                        }
388                    };
389                Ok((GetImageOpenshiftIoAPIGroupResponse::Other(result), read))
390            },
391        }
392    }
393}
394
395// Generated from operation getImageOpenshiftIoV1APIResources
396
397/// get available resources
398///
399/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetImageOpenshiftIoV1APIResourcesResponse`]`>` constructor, or [`GetImageOpenshiftIoV1APIResourcesResponse`] directly, to parse the HTTP response.
400#[cfg(feature = "api")]
401pub fn get_image_openshift_io_v1_api_resources(
402) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetImageOpenshiftIoV1APIResourcesResponse>), k8s_openapi::RequestError> {
403    let __url = "/apis/image.openshift.io/v1/".to_owned();
404
405    let __request = http::Request::get(__url);
406    let __body = vec![];
407    match __request.body(__body) {
408        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
409        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
410    }
411}
412
413/// Use `<GetImageOpenshiftIoV1APIResourcesResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_image_openshift_io_v1_api_resources`]
414#[cfg(feature = "api")]
415#[derive(Debug)]
416pub enum GetImageOpenshiftIoV1APIResourcesResponse {
417    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIResourceList),
418    Other(Result<Option<serde_json::Value>, serde_json::Error>),
419}
420
421#[cfg(feature = "api")]
422impl k8s_openapi::Response for GetImageOpenshiftIoV1APIResourcesResponse {
423    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
424        match status_code {
425            http::StatusCode::OK => {
426                let result = match serde_json::from_slice(buf) {
427                    Ok(value) => value,
428                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
429                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
430                };
431                Ok((GetImageOpenshiftIoV1APIResourcesResponse::Ok(result), buf.len()))
432            },
433            _ => {
434                let (result, read) =
435                    if buf.is_empty() {
436                        (Ok(None), 0)
437                    }
438                    else {
439                        match serde_json::from_slice(buf) {
440                            Ok(value) => (Ok(Some(value)), buf.len()),
441                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
442                            Err(err) => (Err(err), 0),
443                        }
444                    };
445                Ok((GetImageOpenshiftIoV1APIResourcesResponse::Other(result), read))
446            },
447        }
448    }
449}
450
451// Generated from operation getNetworkOpenshiftIoAPIGroup
452
453/// get information of a group
454///
455/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetNetworkOpenshiftIoAPIGroupResponse`]`>` constructor, or [`GetNetworkOpenshiftIoAPIGroupResponse`] directly, to parse the HTTP response.
456#[cfg(feature = "api")]
457pub fn get_network_openshift_io_api_group(
458) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetNetworkOpenshiftIoAPIGroupResponse>), k8s_openapi::RequestError> {
459    let __url = "/apis/network.openshift.io/".to_owned();
460
461    let __request = http::Request::get(__url);
462    let __body = vec![];
463    match __request.body(__body) {
464        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
465        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
466    }
467}
468
469/// Use `<GetNetworkOpenshiftIoAPIGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_network_openshift_io_api_group`]
470#[cfg(feature = "api")]
471#[derive(Debug)]
472pub enum GetNetworkOpenshiftIoAPIGroupResponse {
473    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIGroup),
474    Other(Result<Option<serde_json::Value>, serde_json::Error>),
475}
476
477#[cfg(feature = "api")]
478impl k8s_openapi::Response for GetNetworkOpenshiftIoAPIGroupResponse {
479    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
480        match status_code {
481            http::StatusCode::OK => {
482                let result = match serde_json::from_slice(buf) {
483                    Ok(value) => value,
484                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
485                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
486                };
487                Ok((GetNetworkOpenshiftIoAPIGroupResponse::Ok(result), buf.len()))
488            },
489            _ => {
490                let (result, read) =
491                    if buf.is_empty() {
492                        (Ok(None), 0)
493                    }
494                    else {
495                        match serde_json::from_slice(buf) {
496                            Ok(value) => (Ok(Some(value)), buf.len()),
497                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
498                            Err(err) => (Err(err), 0),
499                        }
500                    };
501                Ok((GetNetworkOpenshiftIoAPIGroupResponse::Other(result), read))
502            },
503        }
504    }
505}
506
507// Generated from operation getNetworkOpenshiftIoV1APIResources
508
509/// get available resources
510///
511/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetNetworkOpenshiftIoV1APIResourcesResponse`]`>` constructor, or [`GetNetworkOpenshiftIoV1APIResourcesResponse`] directly, to parse the HTTP response.
512#[cfg(feature = "api")]
513pub fn get_network_openshift_io_v1_api_resources(
514) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetNetworkOpenshiftIoV1APIResourcesResponse>), k8s_openapi::RequestError> {
515    let __url = "/apis/network.openshift.io/v1/".to_owned();
516
517    let __request = http::Request::get(__url);
518    let __body = vec![];
519    match __request.body(__body) {
520        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
521        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
522    }
523}
524
525/// Use `<GetNetworkOpenshiftIoV1APIResourcesResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_network_openshift_io_v1_api_resources`]
526#[cfg(feature = "api")]
527#[derive(Debug)]
528pub enum GetNetworkOpenshiftIoV1APIResourcesResponse {
529    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIResourceList),
530    Other(Result<Option<serde_json::Value>, serde_json::Error>),
531}
532
533#[cfg(feature = "api")]
534impl k8s_openapi::Response for GetNetworkOpenshiftIoV1APIResourcesResponse {
535    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
536        match status_code {
537            http::StatusCode::OK => {
538                let result = match serde_json::from_slice(buf) {
539                    Ok(value) => value,
540                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
541                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
542                };
543                Ok((GetNetworkOpenshiftIoV1APIResourcesResponse::Ok(result), buf.len()))
544            },
545            _ => {
546                let (result, read) =
547                    if buf.is_empty() {
548                        (Ok(None), 0)
549                    }
550                    else {
551                        match serde_json::from_slice(buf) {
552                            Ok(value) => (Ok(Some(value)), buf.len()),
553                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
554                            Err(err) => (Err(err), 0),
555                        }
556                    };
557                Ok((GetNetworkOpenshiftIoV1APIResourcesResponse::Other(result), read))
558            },
559        }
560    }
561}
562
563// Generated from operation getOauthOpenshiftIoAPIGroup
564
565/// get information of a group
566///
567/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetOauthOpenshiftIoAPIGroupResponse`]`>` constructor, or [`GetOauthOpenshiftIoAPIGroupResponse`] directly, to parse the HTTP response.
568#[cfg(feature = "api")]
569pub fn get_oauth_openshift_io_api_group(
570) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetOauthOpenshiftIoAPIGroupResponse>), k8s_openapi::RequestError> {
571    let __url = "/apis/oauth.openshift.io/".to_owned();
572
573    let __request = http::Request::get(__url);
574    let __body = vec![];
575    match __request.body(__body) {
576        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
577        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
578    }
579}
580
581/// Use `<GetOauthOpenshiftIoAPIGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_oauth_openshift_io_api_group`]
582#[cfg(feature = "api")]
583#[derive(Debug)]
584pub enum GetOauthOpenshiftIoAPIGroupResponse {
585    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIGroup),
586    Other(Result<Option<serde_json::Value>, serde_json::Error>),
587}
588
589#[cfg(feature = "api")]
590impl k8s_openapi::Response for GetOauthOpenshiftIoAPIGroupResponse {
591    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
592        match status_code {
593            http::StatusCode::OK => {
594                let result = match serde_json::from_slice(buf) {
595                    Ok(value) => value,
596                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
597                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
598                };
599                Ok((GetOauthOpenshiftIoAPIGroupResponse::Ok(result), buf.len()))
600            },
601            _ => {
602                let (result, read) =
603                    if buf.is_empty() {
604                        (Ok(None), 0)
605                    }
606                    else {
607                        match serde_json::from_slice(buf) {
608                            Ok(value) => (Ok(Some(value)), buf.len()),
609                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
610                            Err(err) => (Err(err), 0),
611                        }
612                    };
613                Ok((GetOauthOpenshiftIoAPIGroupResponse::Other(result), read))
614            },
615        }
616    }
617}
618
619// Generated from operation getOauthOpenshiftIoV1APIResources
620
621/// get available resources
622///
623/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetOauthOpenshiftIoV1APIResourcesResponse`]`>` constructor, or [`GetOauthOpenshiftIoV1APIResourcesResponse`] directly, to parse the HTTP response.
624#[cfg(feature = "api")]
625pub fn get_oauth_openshift_io_v1_api_resources(
626) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetOauthOpenshiftIoV1APIResourcesResponse>), k8s_openapi::RequestError> {
627    let __url = "/apis/oauth.openshift.io/v1/".to_owned();
628
629    let __request = http::Request::get(__url);
630    let __body = vec![];
631    match __request.body(__body) {
632        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
633        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
634    }
635}
636
637/// Use `<GetOauthOpenshiftIoV1APIResourcesResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_oauth_openshift_io_v1_api_resources`]
638#[cfg(feature = "api")]
639#[derive(Debug)]
640pub enum GetOauthOpenshiftIoV1APIResourcesResponse {
641    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIResourceList),
642    Other(Result<Option<serde_json::Value>, serde_json::Error>),
643}
644
645#[cfg(feature = "api")]
646impl k8s_openapi::Response for GetOauthOpenshiftIoV1APIResourcesResponse {
647    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
648        match status_code {
649            http::StatusCode::OK => {
650                let result = match serde_json::from_slice(buf) {
651                    Ok(value) => value,
652                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
653                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
654                };
655                Ok((GetOauthOpenshiftIoV1APIResourcesResponse::Ok(result), buf.len()))
656            },
657            _ => {
658                let (result, read) =
659                    if buf.is_empty() {
660                        (Ok(None), 0)
661                    }
662                    else {
663                        match serde_json::from_slice(buf) {
664                            Ok(value) => (Ok(Some(value)), buf.len()),
665                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
666                            Err(err) => (Err(err), 0),
667                        }
668                    };
669                Ok((GetOauthOpenshiftIoV1APIResourcesResponse::Other(result), read))
670            },
671        }
672    }
673}
674
675// Generated from operation getProjectOpenshiftIoAPIGroup
676
677/// get information of a group
678///
679/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetProjectOpenshiftIoAPIGroupResponse`]`>` constructor, or [`GetProjectOpenshiftIoAPIGroupResponse`] directly, to parse the HTTP response.
680#[cfg(feature = "api")]
681pub fn get_project_openshift_io_api_group(
682) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetProjectOpenshiftIoAPIGroupResponse>), k8s_openapi::RequestError> {
683    let __url = "/apis/project.openshift.io/".to_owned();
684
685    let __request = http::Request::get(__url);
686    let __body = vec![];
687    match __request.body(__body) {
688        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
689        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
690    }
691}
692
693/// Use `<GetProjectOpenshiftIoAPIGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_project_openshift_io_api_group`]
694#[cfg(feature = "api")]
695#[derive(Debug)]
696pub enum GetProjectOpenshiftIoAPIGroupResponse {
697    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIGroup),
698    Other(Result<Option<serde_json::Value>, serde_json::Error>),
699}
700
701#[cfg(feature = "api")]
702impl k8s_openapi::Response for GetProjectOpenshiftIoAPIGroupResponse {
703    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
704        match status_code {
705            http::StatusCode::OK => {
706                let result = match serde_json::from_slice(buf) {
707                    Ok(value) => value,
708                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
709                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
710                };
711                Ok((GetProjectOpenshiftIoAPIGroupResponse::Ok(result), buf.len()))
712            },
713            _ => {
714                let (result, read) =
715                    if buf.is_empty() {
716                        (Ok(None), 0)
717                    }
718                    else {
719                        match serde_json::from_slice(buf) {
720                            Ok(value) => (Ok(Some(value)), buf.len()),
721                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
722                            Err(err) => (Err(err), 0),
723                        }
724                    };
725                Ok((GetProjectOpenshiftIoAPIGroupResponse::Other(result), read))
726            },
727        }
728    }
729}
730
731// Generated from operation getProjectOpenshiftIoV1APIResources
732
733/// get available resources
734///
735/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetProjectOpenshiftIoV1APIResourcesResponse`]`>` constructor, or [`GetProjectOpenshiftIoV1APIResourcesResponse`] directly, to parse the HTTP response.
736#[cfg(feature = "api")]
737pub fn get_project_openshift_io_v1_api_resources(
738) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetProjectOpenshiftIoV1APIResourcesResponse>), k8s_openapi::RequestError> {
739    let __url = "/apis/project.openshift.io/v1/".to_owned();
740
741    let __request = http::Request::get(__url);
742    let __body = vec![];
743    match __request.body(__body) {
744        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
745        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
746    }
747}
748
749/// Use `<GetProjectOpenshiftIoV1APIResourcesResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_project_openshift_io_v1_api_resources`]
750#[cfg(feature = "api")]
751#[derive(Debug)]
752pub enum GetProjectOpenshiftIoV1APIResourcesResponse {
753    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIResourceList),
754    Other(Result<Option<serde_json::Value>, serde_json::Error>),
755}
756
757#[cfg(feature = "api")]
758impl k8s_openapi::Response for GetProjectOpenshiftIoV1APIResourcesResponse {
759    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
760        match status_code {
761            http::StatusCode::OK => {
762                let result = match serde_json::from_slice(buf) {
763                    Ok(value) => value,
764                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
765                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
766                };
767                Ok((GetProjectOpenshiftIoV1APIResourcesResponse::Ok(result), buf.len()))
768            },
769            _ => {
770                let (result, read) =
771                    if buf.is_empty() {
772                        (Ok(None), 0)
773                    }
774                    else {
775                        match serde_json::from_slice(buf) {
776                            Ok(value) => (Ok(Some(value)), buf.len()),
777                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
778                            Err(err) => (Err(err), 0),
779                        }
780                    };
781                Ok((GetProjectOpenshiftIoV1APIResourcesResponse::Other(result), read))
782            },
783        }
784    }
785}
786
787// Generated from operation getQuotaOpenshiftIoAPIGroup
788
789/// get information of a group
790///
791/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetQuotaOpenshiftIoAPIGroupResponse`]`>` constructor, or [`GetQuotaOpenshiftIoAPIGroupResponse`] directly, to parse the HTTP response.
792#[cfg(feature = "api")]
793pub fn get_quota_openshift_io_api_group(
794) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetQuotaOpenshiftIoAPIGroupResponse>), k8s_openapi::RequestError> {
795    let __url = "/apis/quota.openshift.io/".to_owned();
796
797    let __request = http::Request::get(__url);
798    let __body = vec![];
799    match __request.body(__body) {
800        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
801        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
802    }
803}
804
805/// Use `<GetQuotaOpenshiftIoAPIGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_quota_openshift_io_api_group`]
806#[cfg(feature = "api")]
807#[derive(Debug)]
808pub enum GetQuotaOpenshiftIoAPIGroupResponse {
809    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIGroup),
810    Other(Result<Option<serde_json::Value>, serde_json::Error>),
811}
812
813#[cfg(feature = "api")]
814impl k8s_openapi::Response for GetQuotaOpenshiftIoAPIGroupResponse {
815    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
816        match status_code {
817            http::StatusCode::OK => {
818                let result = match serde_json::from_slice(buf) {
819                    Ok(value) => value,
820                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
821                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
822                };
823                Ok((GetQuotaOpenshiftIoAPIGroupResponse::Ok(result), buf.len()))
824            },
825            _ => {
826                let (result, read) =
827                    if buf.is_empty() {
828                        (Ok(None), 0)
829                    }
830                    else {
831                        match serde_json::from_slice(buf) {
832                            Ok(value) => (Ok(Some(value)), buf.len()),
833                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
834                            Err(err) => (Err(err), 0),
835                        }
836                    };
837                Ok((GetQuotaOpenshiftIoAPIGroupResponse::Other(result), read))
838            },
839        }
840    }
841}
842
843// Generated from operation getQuotaOpenshiftIoV1APIResources
844
845/// get available resources
846///
847/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetQuotaOpenshiftIoV1APIResourcesResponse`]`>` constructor, or [`GetQuotaOpenshiftIoV1APIResourcesResponse`] directly, to parse the HTTP response.
848#[cfg(feature = "api")]
849pub fn get_quota_openshift_io_v1_api_resources(
850) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetQuotaOpenshiftIoV1APIResourcesResponse>), k8s_openapi::RequestError> {
851    let __url = "/apis/quota.openshift.io/v1/".to_owned();
852
853    let __request = http::Request::get(__url);
854    let __body = vec![];
855    match __request.body(__body) {
856        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
857        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
858    }
859}
860
861/// Use `<GetQuotaOpenshiftIoV1APIResourcesResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_quota_openshift_io_v1_api_resources`]
862#[cfg(feature = "api")]
863#[derive(Debug)]
864pub enum GetQuotaOpenshiftIoV1APIResourcesResponse {
865    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIResourceList),
866    Other(Result<Option<serde_json::Value>, serde_json::Error>),
867}
868
869#[cfg(feature = "api")]
870impl k8s_openapi::Response for GetQuotaOpenshiftIoV1APIResourcesResponse {
871    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
872        match status_code {
873            http::StatusCode::OK => {
874                let result = match serde_json::from_slice(buf) {
875                    Ok(value) => value,
876                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
877                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
878                };
879                Ok((GetQuotaOpenshiftIoV1APIResourcesResponse::Ok(result), buf.len()))
880            },
881            _ => {
882                let (result, read) =
883                    if buf.is_empty() {
884                        (Ok(None), 0)
885                    }
886                    else {
887                        match serde_json::from_slice(buf) {
888                            Ok(value) => (Ok(Some(value)), buf.len()),
889                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
890                            Err(err) => (Err(err), 0),
891                        }
892                    };
893                Ok((GetQuotaOpenshiftIoV1APIResourcesResponse::Other(result), read))
894            },
895        }
896    }
897}
898
899// Generated from operation getRouteOpenshiftIoAPIGroup
900
901/// get information of a group
902///
903/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetRouteOpenshiftIoAPIGroupResponse`]`>` constructor, or [`GetRouteOpenshiftIoAPIGroupResponse`] directly, to parse the HTTP response.
904#[cfg(feature = "api")]
905pub fn get_route_openshift_io_api_group(
906) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetRouteOpenshiftIoAPIGroupResponse>), k8s_openapi::RequestError> {
907    let __url = "/apis/route.openshift.io/".to_owned();
908
909    let __request = http::Request::get(__url);
910    let __body = vec![];
911    match __request.body(__body) {
912        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
913        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
914    }
915}
916
917/// Use `<GetRouteOpenshiftIoAPIGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_route_openshift_io_api_group`]
918#[cfg(feature = "api")]
919#[derive(Debug)]
920pub enum GetRouteOpenshiftIoAPIGroupResponse {
921    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIGroup),
922    Other(Result<Option<serde_json::Value>, serde_json::Error>),
923}
924
925#[cfg(feature = "api")]
926impl k8s_openapi::Response for GetRouteOpenshiftIoAPIGroupResponse {
927    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
928        match status_code {
929            http::StatusCode::OK => {
930                let result = match serde_json::from_slice(buf) {
931                    Ok(value) => value,
932                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
933                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
934                };
935                Ok((GetRouteOpenshiftIoAPIGroupResponse::Ok(result), buf.len()))
936            },
937            _ => {
938                let (result, read) =
939                    if buf.is_empty() {
940                        (Ok(None), 0)
941                    }
942                    else {
943                        match serde_json::from_slice(buf) {
944                            Ok(value) => (Ok(Some(value)), buf.len()),
945                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
946                            Err(err) => (Err(err), 0),
947                        }
948                    };
949                Ok((GetRouteOpenshiftIoAPIGroupResponse::Other(result), read))
950            },
951        }
952    }
953}
954
955// Generated from operation getRouteOpenshiftIoV1APIResources
956
957/// get available resources
958///
959/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetRouteOpenshiftIoV1APIResourcesResponse`]`>` constructor, or [`GetRouteOpenshiftIoV1APIResourcesResponse`] directly, to parse the HTTP response.
960#[cfg(feature = "api")]
961pub fn get_route_openshift_io_v1_api_resources(
962) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetRouteOpenshiftIoV1APIResourcesResponse>), k8s_openapi::RequestError> {
963    let __url = "/apis/route.openshift.io/v1/".to_owned();
964
965    let __request = http::Request::get(__url);
966    let __body = vec![];
967    match __request.body(__body) {
968        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
969        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
970    }
971}
972
973/// Use `<GetRouteOpenshiftIoV1APIResourcesResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_route_openshift_io_v1_api_resources`]
974#[cfg(feature = "api")]
975#[derive(Debug)]
976pub enum GetRouteOpenshiftIoV1APIResourcesResponse {
977    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIResourceList),
978    Other(Result<Option<serde_json::Value>, serde_json::Error>),
979}
980
981#[cfg(feature = "api")]
982impl k8s_openapi::Response for GetRouteOpenshiftIoV1APIResourcesResponse {
983    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
984        match status_code {
985            http::StatusCode::OK => {
986                let result = match serde_json::from_slice(buf) {
987                    Ok(value) => value,
988                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
989                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
990                };
991                Ok((GetRouteOpenshiftIoV1APIResourcesResponse::Ok(result), buf.len()))
992            },
993            _ => {
994                let (result, read) =
995                    if buf.is_empty() {
996                        (Ok(None), 0)
997                    }
998                    else {
999                        match serde_json::from_slice(buf) {
1000                            Ok(value) => (Ok(Some(value)), buf.len()),
1001                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1002                            Err(err) => (Err(err), 0),
1003                        }
1004                    };
1005                Ok((GetRouteOpenshiftIoV1APIResourcesResponse::Other(result), read))
1006            },
1007        }
1008    }
1009}
1010
1011// Generated from operation getSecurityOpenshiftIoAPIGroup
1012
1013/// get information of a group
1014///
1015/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetSecurityOpenshiftIoAPIGroupResponse`]`>` constructor, or [`GetSecurityOpenshiftIoAPIGroupResponse`] directly, to parse the HTTP response.
1016#[cfg(feature = "api")]
1017pub fn get_security_openshift_io_api_group(
1018) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetSecurityOpenshiftIoAPIGroupResponse>), k8s_openapi::RequestError> {
1019    let __url = "/apis/security.openshift.io/".to_owned();
1020
1021    let __request = http::Request::get(__url);
1022    let __body = vec![];
1023    match __request.body(__body) {
1024        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
1025        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
1026    }
1027}
1028
1029/// Use `<GetSecurityOpenshiftIoAPIGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_security_openshift_io_api_group`]
1030#[cfg(feature = "api")]
1031#[derive(Debug)]
1032pub enum GetSecurityOpenshiftIoAPIGroupResponse {
1033    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIGroup),
1034    Other(Result<Option<serde_json::Value>, serde_json::Error>),
1035}
1036
1037#[cfg(feature = "api")]
1038impl k8s_openapi::Response for GetSecurityOpenshiftIoAPIGroupResponse {
1039    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
1040        match status_code {
1041            http::StatusCode::OK => {
1042                let result = match serde_json::from_slice(buf) {
1043                    Ok(value) => value,
1044                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1045                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
1046                };
1047                Ok((GetSecurityOpenshiftIoAPIGroupResponse::Ok(result), buf.len()))
1048            },
1049            _ => {
1050                let (result, read) =
1051                    if buf.is_empty() {
1052                        (Ok(None), 0)
1053                    }
1054                    else {
1055                        match serde_json::from_slice(buf) {
1056                            Ok(value) => (Ok(Some(value)), buf.len()),
1057                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1058                            Err(err) => (Err(err), 0),
1059                        }
1060                    };
1061                Ok((GetSecurityOpenshiftIoAPIGroupResponse::Other(result), read))
1062            },
1063        }
1064    }
1065}
1066
1067// Generated from operation getSecurityOpenshiftIoV1APIResources
1068
1069/// get available resources
1070///
1071/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetSecurityOpenshiftIoV1APIResourcesResponse`]`>` constructor, or [`GetSecurityOpenshiftIoV1APIResourcesResponse`] directly, to parse the HTTP response.
1072#[cfg(feature = "api")]
1073pub fn get_security_openshift_io_v1_api_resources(
1074) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetSecurityOpenshiftIoV1APIResourcesResponse>), k8s_openapi::RequestError> {
1075    let __url = "/apis/security.openshift.io/v1/".to_owned();
1076
1077    let __request = http::Request::get(__url);
1078    let __body = vec![];
1079    match __request.body(__body) {
1080        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
1081        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
1082    }
1083}
1084
1085/// Use `<GetSecurityOpenshiftIoV1APIResourcesResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_security_openshift_io_v1_api_resources`]
1086#[cfg(feature = "api")]
1087#[derive(Debug)]
1088pub enum GetSecurityOpenshiftIoV1APIResourcesResponse {
1089    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIResourceList),
1090    Other(Result<Option<serde_json::Value>, serde_json::Error>),
1091}
1092
1093#[cfg(feature = "api")]
1094impl k8s_openapi::Response for GetSecurityOpenshiftIoV1APIResourcesResponse {
1095    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
1096        match status_code {
1097            http::StatusCode::OK => {
1098                let result = match serde_json::from_slice(buf) {
1099                    Ok(value) => value,
1100                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1101                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
1102                };
1103                Ok((GetSecurityOpenshiftIoV1APIResourcesResponse::Ok(result), buf.len()))
1104            },
1105            _ => {
1106                let (result, read) =
1107                    if buf.is_empty() {
1108                        (Ok(None), 0)
1109                    }
1110                    else {
1111                        match serde_json::from_slice(buf) {
1112                            Ok(value) => (Ok(Some(value)), buf.len()),
1113                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1114                            Err(err) => (Err(err), 0),
1115                        }
1116                    };
1117                Ok((GetSecurityOpenshiftIoV1APIResourcesResponse::Other(result), read))
1118            },
1119        }
1120    }
1121}
1122
1123// Generated from operation getTemplateOpenshiftIoAPIGroup
1124
1125/// get information of a group
1126///
1127/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetTemplateOpenshiftIoAPIGroupResponse`]`>` constructor, or [`GetTemplateOpenshiftIoAPIGroupResponse`] directly, to parse the HTTP response.
1128#[cfg(feature = "api")]
1129pub fn get_template_openshift_io_api_group(
1130) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetTemplateOpenshiftIoAPIGroupResponse>), k8s_openapi::RequestError> {
1131    let __url = "/apis/template.openshift.io/".to_owned();
1132
1133    let __request = http::Request::get(__url);
1134    let __body = vec![];
1135    match __request.body(__body) {
1136        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
1137        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
1138    }
1139}
1140
1141/// Use `<GetTemplateOpenshiftIoAPIGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_template_openshift_io_api_group`]
1142#[cfg(feature = "api")]
1143#[derive(Debug)]
1144pub enum GetTemplateOpenshiftIoAPIGroupResponse {
1145    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIGroup),
1146    Other(Result<Option<serde_json::Value>, serde_json::Error>),
1147}
1148
1149#[cfg(feature = "api")]
1150impl k8s_openapi::Response for GetTemplateOpenshiftIoAPIGroupResponse {
1151    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
1152        match status_code {
1153            http::StatusCode::OK => {
1154                let result = match serde_json::from_slice(buf) {
1155                    Ok(value) => value,
1156                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1157                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
1158                };
1159                Ok((GetTemplateOpenshiftIoAPIGroupResponse::Ok(result), buf.len()))
1160            },
1161            _ => {
1162                let (result, read) =
1163                    if buf.is_empty() {
1164                        (Ok(None), 0)
1165                    }
1166                    else {
1167                        match serde_json::from_slice(buf) {
1168                            Ok(value) => (Ok(Some(value)), buf.len()),
1169                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1170                            Err(err) => (Err(err), 0),
1171                        }
1172                    };
1173                Ok((GetTemplateOpenshiftIoAPIGroupResponse::Other(result), read))
1174            },
1175        }
1176    }
1177}
1178
1179// Generated from operation getTemplateOpenshiftIoV1APIResources
1180
1181/// get available resources
1182///
1183/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetTemplateOpenshiftIoV1APIResourcesResponse`]`>` constructor, or [`GetTemplateOpenshiftIoV1APIResourcesResponse`] directly, to parse the HTTP response.
1184#[cfg(feature = "api")]
1185pub fn get_template_openshift_io_v1_api_resources(
1186) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetTemplateOpenshiftIoV1APIResourcesResponse>), k8s_openapi::RequestError> {
1187    let __url = "/apis/template.openshift.io/v1/".to_owned();
1188
1189    let __request = http::Request::get(__url);
1190    let __body = vec![];
1191    match __request.body(__body) {
1192        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
1193        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
1194    }
1195}
1196
1197/// Use `<GetTemplateOpenshiftIoV1APIResourcesResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_template_openshift_io_v1_api_resources`]
1198#[cfg(feature = "api")]
1199#[derive(Debug)]
1200pub enum GetTemplateOpenshiftIoV1APIResourcesResponse {
1201    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIResourceList),
1202    Other(Result<Option<serde_json::Value>, serde_json::Error>),
1203}
1204
1205#[cfg(feature = "api")]
1206impl k8s_openapi::Response for GetTemplateOpenshiftIoV1APIResourcesResponse {
1207    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
1208        match status_code {
1209            http::StatusCode::OK => {
1210                let result = match serde_json::from_slice(buf) {
1211                    Ok(value) => value,
1212                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1213                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
1214                };
1215                Ok((GetTemplateOpenshiftIoV1APIResourcesResponse::Ok(result), buf.len()))
1216            },
1217            _ => {
1218                let (result, read) =
1219                    if buf.is_empty() {
1220                        (Ok(None), 0)
1221                    }
1222                    else {
1223                        match serde_json::from_slice(buf) {
1224                            Ok(value) => (Ok(Some(value)), buf.len()),
1225                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1226                            Err(err) => (Err(err), 0),
1227                        }
1228                    };
1229                Ok((GetTemplateOpenshiftIoV1APIResourcesResponse::Other(result), read))
1230            },
1231        }
1232    }
1233}
1234
1235// Generated from operation getUserOpenshiftIoAPIGroup
1236
1237/// get information of a group
1238///
1239/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetUserOpenshiftIoAPIGroupResponse`]`>` constructor, or [`GetUserOpenshiftIoAPIGroupResponse`] directly, to parse the HTTP response.
1240#[cfg(feature = "api")]
1241pub fn get_user_openshift_io_api_group(
1242) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetUserOpenshiftIoAPIGroupResponse>), k8s_openapi::RequestError> {
1243    let __url = "/apis/user.openshift.io/".to_owned();
1244
1245    let __request = http::Request::get(__url);
1246    let __body = vec![];
1247    match __request.body(__body) {
1248        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
1249        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
1250    }
1251}
1252
1253/// Use `<GetUserOpenshiftIoAPIGroupResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_user_openshift_io_api_group`]
1254#[cfg(feature = "api")]
1255#[derive(Debug)]
1256pub enum GetUserOpenshiftIoAPIGroupResponse {
1257    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIGroup),
1258    Other(Result<Option<serde_json::Value>, serde_json::Error>),
1259}
1260
1261#[cfg(feature = "api")]
1262impl k8s_openapi::Response for GetUserOpenshiftIoAPIGroupResponse {
1263    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
1264        match status_code {
1265            http::StatusCode::OK => {
1266                let result = match serde_json::from_slice(buf) {
1267                    Ok(value) => value,
1268                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1269                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
1270                };
1271                Ok((GetUserOpenshiftIoAPIGroupResponse::Ok(result), buf.len()))
1272            },
1273            _ => {
1274                let (result, read) =
1275                    if buf.is_empty() {
1276                        (Ok(None), 0)
1277                    }
1278                    else {
1279                        match serde_json::from_slice(buf) {
1280                            Ok(value) => (Ok(Some(value)), buf.len()),
1281                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1282                            Err(err) => (Err(err), 0),
1283                        }
1284                    };
1285                Ok((GetUserOpenshiftIoAPIGroupResponse::Other(result), read))
1286            },
1287        }
1288    }
1289}
1290
1291// Generated from operation getUserOpenshiftIoV1APIResources
1292
1293/// get available resources
1294///
1295/// Use the returned [`k8s_openapi::ResponseBody`]`<`[`GetUserOpenshiftIoV1APIResourcesResponse`]`>` constructor, or [`GetUserOpenshiftIoV1APIResourcesResponse`] directly, to parse the HTTP response.
1296#[cfg(feature = "api")]
1297pub fn get_user_openshift_io_v1_api_resources(
1298) -> Result<(http::Request<Vec<u8>>, fn(http::StatusCode) -> k8s_openapi::ResponseBody<GetUserOpenshiftIoV1APIResourcesResponse>), k8s_openapi::RequestError> {
1299    let __url = "/apis/user.openshift.io/v1/".to_owned();
1300
1301    let __request = http::Request::get(__url);
1302    let __body = vec![];
1303    match __request.body(__body) {
1304        Ok(request) => Ok((request, k8s_openapi::ResponseBody::new)),
1305        Err(err) => Err(k8s_openapi::RequestError::Http(err)),
1306    }
1307}
1308
1309/// Use `<GetUserOpenshiftIoV1APIResourcesResponse as Response>::try_from_parts` to parse the HTTP response body of [`get_user_openshift_io_v1_api_resources`]
1310#[cfg(feature = "api")]
1311#[derive(Debug)]
1312pub enum GetUserOpenshiftIoV1APIResourcesResponse {
1313    Ok(k8s_openapi::apimachinery::pkg::apis::meta::v1::APIResourceList),
1314    Other(Result<Option<serde_json::Value>, serde_json::Error>),
1315}
1316
1317#[cfg(feature = "api")]
1318impl k8s_openapi::Response for GetUserOpenshiftIoV1APIResourcesResponse {
1319    fn try_from_parts(status_code: http::StatusCode, buf: &[u8]) -> Result<(Self, usize), k8s_openapi::ResponseError> {
1320        match status_code {
1321            http::StatusCode::OK => {
1322                let result = match serde_json::from_slice(buf) {
1323                    Ok(value) => value,
1324                    Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1325                    Err(err) => return Err(k8s_openapi::ResponseError::Json(err)),
1326                };
1327                Ok((GetUserOpenshiftIoV1APIResourcesResponse::Ok(result), buf.len()))
1328            },
1329            _ => {
1330                let (result, read) =
1331                    if buf.is_empty() {
1332                        (Ok(None), 0)
1333                    }
1334                    else {
1335                        match serde_json::from_slice(buf) {
1336                            Ok(value) => (Ok(Some(value)), buf.len()),
1337                            Err(ref err) if err.is_eof() => return Err(k8s_openapi::ResponseError::NeedMoreData),
1338                            Err(err) => (Err(err), 0),
1339                        }
1340                    };
1341                Ok((GetUserOpenshiftIoV1APIResourcesResponse::Other(result), read))
1342            },
1343        }
1344    }
1345}
openshift_openapi/v4_5/mod.rs

openshift_openapi/v4_5/
mod.rs
