1#[non_exhaustive]
4#[derive(std::clone::Clone, std::cmp::PartialEq)]
5pub struct PrometheusTargetOperationOutput {
6 pub targets: std::option::Option<std::vec::Vec<crate::model::PrometheusTarget>>,
8}
9impl PrometheusTargetOperationOutput {
10 pub fn targets(&self) -> std::option::Option<&[crate::model::PrometheusTarget]> {
12 self.targets.as_deref()
13 }
14}
15impl std::fmt::Debug for PrometheusTargetOperationOutput {
16 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17 let mut formatter = f.debug_struct("PrometheusTargetOperationOutput");
18 formatter.field("targets", &self.targets);
19 formatter.finish()
20 }
21}
22pub mod prometheus_target_operation_output {
24 #[non_exhaustive]
26 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
27 pub struct Builder {
28 pub(crate) targets: std::option::Option<std::vec::Vec<crate::model::PrometheusTarget>>,
29 }
30 impl Builder {
31 pub fn targets(mut self, input: crate::model::PrometheusTarget) -> Self {
37 let mut v = self.targets.unwrap_or_default();
38 v.push(input);
39 self.targets = Some(v);
40 self
41 }
42 pub fn set_targets(
44 mut self,
45 input: std::option::Option<std::vec::Vec<crate::model::PrometheusTarget>>,
46 ) -> Self {
47 self.targets = input;
48 self
49 }
50 pub fn build(self) -> crate::output::PrometheusTargetOperationOutput {
52 crate::output::PrometheusTargetOperationOutput {
53 targets: self.targets,
54 }
55 }
56 }
57}
58impl PrometheusTargetOperationOutput {
59 pub fn builder() -> crate::output::prometheus_target_operation_output::Builder {
61 crate::output::prometheus_target_operation_output::Builder::default()
62 }
63}
64
65#[non_exhaustive]
67#[derive(std::clone::Clone, std::cmp::PartialEq)]
68pub struct RestartOperationOutput {
69 pub inner: std::option::Option<std::vec::Vec<crate::model::SystemdOutputInner>>,
71}
72impl RestartOperationOutput {
73 pub fn inner(&self) -> std::option::Option<&[crate::model::SystemdOutputInner]> {
75 self.inner.as_deref()
76 }
77}
78impl std::fmt::Debug for RestartOperationOutput {
79 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
80 let mut formatter = f.debug_struct("RestartOperationOutput");
81 formatter.field("inner", &self.inner);
82 formatter.finish()
83 }
84}
85pub mod restart_operation_output {
87 #[non_exhaustive]
89 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
90 pub struct Builder {
91 pub(crate) inner: std::option::Option<std::vec::Vec<crate::model::SystemdOutputInner>>,
92 }
93 impl Builder {
94 pub fn inner(mut self, input: crate::model::SystemdOutputInner) -> Self {
100 let mut v = self.inner.unwrap_or_default();
101 v.push(input);
102 self.inner = Some(v);
103 self
104 }
105 pub fn set_inner(
107 mut self,
108 input: std::option::Option<std::vec::Vec<crate::model::SystemdOutputInner>>,
109 ) -> Self {
110 self.inner = input;
111 self
112 }
113 pub fn build(self) -> crate::output::RestartOperationOutput {
115 crate::output::RestartOperationOutput { inner: self.inner }
116 }
117 }
118}
119impl RestartOperationOutput {
120 pub fn builder() -> crate::output::restart_operation_output::Builder {
122 crate::output::restart_operation_output::Builder::default()
123 }
124}
125
126#[non_exhaustive]
128#[derive(std::clone::Clone, std::cmp::PartialEq)]
129pub struct StopOperationOutput {
130 pub inner: std::option::Option<std::vec::Vec<crate::model::SystemdOutputInner>>,
132}
133impl StopOperationOutput {
134 pub fn inner(&self) -> std::option::Option<&[crate::model::SystemdOutputInner]> {
136 self.inner.as_deref()
137 }
138}
139impl std::fmt::Debug for StopOperationOutput {
140 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
141 let mut formatter = f.debug_struct("StopOperationOutput");
142 formatter.field("inner", &self.inner);
143 formatter.finish()
144 }
145}
146pub mod stop_operation_output {
148 #[non_exhaustive]
150 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
151 pub struct Builder {
152 pub(crate) inner: std::option::Option<std::vec::Vec<crate::model::SystemdOutputInner>>,
153 }
154 impl Builder {
155 pub fn inner(mut self, input: crate::model::SystemdOutputInner) -> Self {
161 let mut v = self.inner.unwrap_or_default();
162 v.push(input);
163 self.inner = Some(v);
164 self
165 }
166 pub fn set_inner(
168 mut self,
169 input: std::option::Option<std::vec::Vec<crate::model::SystemdOutputInner>>,
170 ) -> Self {
171 self.inner = input;
172 self
173 }
174 pub fn build(self) -> crate::output::StopOperationOutput {
176 crate::output::StopOperationOutput { inner: self.inner }
177 }
178 }
179}
180impl StopOperationOutput {
181 pub fn builder() -> crate::output::stop_operation_output::Builder {
183 crate::output::stop_operation_output::Builder::default()
184 }
185}
186
187#[non_exhaustive]
189#[derive(std::clone::Clone, std::cmp::PartialEq)]
190pub struct StartOperationOutput {
191 pub inner: std::option::Option<std::vec::Vec<crate::model::SystemdOutputInner>>,
193}
194impl StartOperationOutput {
195 pub fn inner(&self) -> std::option::Option<&[crate::model::SystemdOutputInner]> {
197 self.inner.as_deref()
198 }
199}
200impl std::fmt::Debug for StartOperationOutput {
201 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
202 let mut formatter = f.debug_struct("StartOperationOutput");
203 formatter.field("inner", &self.inner);
204 formatter.finish()
205 }
206}
207pub mod start_operation_output {
209 #[non_exhaustive]
211 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
212 pub struct Builder {
213 pub(crate) inner: std::option::Option<std::vec::Vec<crate::model::SystemdOutputInner>>,
214 }
215 impl Builder {
216 pub fn inner(mut self, input: crate::model::SystemdOutputInner) -> Self {
222 let mut v = self.inner.unwrap_or_default();
223 v.push(input);
224 self.inner = Some(v);
225 self
226 }
227 pub fn set_inner(
229 mut self,
230 input: std::option::Option<std::vec::Vec<crate::model::SystemdOutputInner>>,
231 ) -> Self {
232 self.inner = input;
233 self
234 }
235 pub fn build(self) -> crate::output::StartOperationOutput {
237 crate::output::StartOperationOutput { inner: self.inner }
238 }
239 }
240}
241impl StartOperationOutput {
242 pub fn builder() -> crate::output::start_operation_output::Builder {
244 crate::output::start_operation_output::Builder::default()
245 }
246}
247
248#[non_exhaustive]
250#[derive(std::clone::Clone, std::cmp::PartialEq)]
251pub struct ListOperationOutput {
252 pub primary: std::option::Option<std::string::String>,
254 pub host: std::option::Option<crate::model::Host>,
256 pub resources: std::option::Option<crate::model::Resources>,
258 pub services: std::option::Option<std::vec::Vec<crate::model::Service>>,
260 pub checksum: std::option::Option<std::string::String>,
262 pub available_services: std::option::Option<std::vec::Vec<std::string::String>>,
264 pub peers: std::option::Option<
266 std::collections::HashMap<std::string::String, crate::model::ListOutput>,
267 >,
268}
269impl ListOperationOutput {
270 pub fn primary(&self) -> std::option::Option<&str> {
272 self.primary.as_deref()
273 }
274 pub fn host(&self) -> std::option::Option<&crate::model::Host> {
276 self.host.as_ref()
277 }
278 pub fn resources(&self) -> std::option::Option<&crate::model::Resources> {
280 self.resources.as_ref()
281 }
282 pub fn services(&self) -> std::option::Option<&[crate::model::Service]> {
284 self.services.as_deref()
285 }
286 pub fn checksum(&self) -> std::option::Option<&str> {
288 self.checksum.as_deref()
289 }
290 pub fn available_services(&self) -> std::option::Option<&[std::string::String]> {
292 self.available_services.as_deref()
293 }
294 pub fn peers(
296 &self,
297 ) -> std::option::Option<
298 &std::collections::HashMap<std::string::String, crate::model::ListOutput>,
299 > {
300 self.peers.as_ref()
301 }
302}
303impl std::fmt::Debug for ListOperationOutput {
304 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
305 let mut formatter = f.debug_struct("ListOperationOutput");
306 formatter.field("primary", &self.primary);
307 formatter.field("host", &self.host);
308 formatter.field("resources", &self.resources);
309 formatter.field("services", &self.services);
310 formatter.field("checksum", &self.checksum);
311 formatter.field("available_services", &self.available_services);
312 formatter.field("peers", &self.peers);
313 formatter.finish()
314 }
315}
316pub mod list_operation_output {
318 #[non_exhaustive]
320 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
321 pub struct Builder {
322 pub(crate) primary: std::option::Option<std::string::String>,
323 pub(crate) host: std::option::Option<crate::model::Host>,
324 pub(crate) resources: std::option::Option<crate::model::Resources>,
325 pub(crate) services: std::option::Option<std::vec::Vec<crate::model::Service>>,
326 pub(crate) checksum: std::option::Option<std::string::String>,
327 pub(crate) available_services: std::option::Option<std::vec::Vec<std::string::String>>,
328 pub(crate) peers: std::option::Option<
329 std::collections::HashMap<std::string::String, crate::model::ListOutput>,
330 >,
331 }
332 impl Builder {
333 pub fn primary(mut self, input: impl Into<std::string::String>) -> Self {
335 self.primary = Some(input.into());
336 self
337 }
338 pub fn set_primary(mut self, input: std::option::Option<std::string::String>) -> Self {
340 self.primary = input;
341 self
342 }
343 pub fn host(mut self, input: crate::model::Host) -> Self {
345 self.host = Some(input);
346 self
347 }
348 pub fn set_host(mut self, input: std::option::Option<crate::model::Host>) -> Self {
350 self.host = input;
351 self
352 }
353 pub fn resources(mut self, input: crate::model::Resources) -> Self {
355 self.resources = Some(input);
356 self
357 }
358 pub fn set_resources(
360 mut self,
361 input: std::option::Option<crate::model::Resources>,
362 ) -> Self {
363 self.resources = input;
364 self
365 }
366 pub fn services(mut self, input: crate::model::Service) -> Self {
372 let mut v = self.services.unwrap_or_default();
373 v.push(input);
374 self.services = Some(v);
375 self
376 }
377 pub fn set_services(
379 mut self,
380 input: std::option::Option<std::vec::Vec<crate::model::Service>>,
381 ) -> Self {
382 self.services = input;
383 self
384 }
385 pub fn checksum(mut self, input: impl Into<std::string::String>) -> Self {
387 self.checksum = Some(input.into());
388 self
389 }
390 pub fn set_checksum(mut self, input: std::option::Option<std::string::String>) -> Self {
392 self.checksum = input;
393 self
394 }
395 pub fn available_services(mut self, input: impl Into<std::string::String>) -> Self {
401 let mut v = self.available_services.unwrap_or_default();
402 v.push(input.into());
403 self.available_services = Some(v);
404 self
405 }
406 pub fn set_available_services(
408 mut self,
409 input: std::option::Option<std::vec::Vec<std::string::String>>,
410 ) -> Self {
411 self.available_services = input;
412 self
413 }
414 pub fn peers(
420 mut self,
421 k: impl Into<std::string::String>,
422 v: crate::model::ListOutput,
423 ) -> Self {
424 let mut hash_map = self.peers.unwrap_or_default();
425 hash_map.insert(k.into(), v);
426 self.peers = Some(hash_map);
427 self
428 }
429 pub fn set_peers(
431 mut self,
432 input: std::option::Option<
433 std::collections::HashMap<std::string::String, crate::model::ListOutput>,
434 >,
435 ) -> Self {
436 self.peers = input;
437 self
438 }
439 pub fn build(self) -> crate::output::ListOperationOutput {
441 crate::output::ListOperationOutput {
442 primary: self.primary,
443 host: self.host,
444 resources: self.resources,
445 services: self.services,
446 checksum: self.checksum,
447 available_services: self.available_services,
448 peers: self.peers,
449 }
450 }
451 }
452}
453impl ListOperationOutput {
454 pub fn builder() -> crate::output::list_operation_output::Builder {
456 crate::output::list_operation_output::Builder::default()
457 }
458}
459
460#[non_exhaustive]
462#[derive(std::clone::Clone, std::cmp::PartialEq)]
463pub struct HealthcheckOperationOutput {
464 #[allow(missing_docs)] pub message: std::option::Option<std::string::String>,
466}
467impl HealthcheckOperationOutput {
468 #[allow(missing_docs)] pub fn message(&self) -> std::option::Option<&str> {
470 self.message.as_deref()
471 }
472}
473impl std::fmt::Debug for HealthcheckOperationOutput {
474 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
475 let mut formatter = f.debug_struct("HealthcheckOperationOutput");
476 formatter.field("message", &self.message);
477 formatter.finish()
478 }
479}
480pub mod healthcheck_operation_output {
482 #[non_exhaustive]
484 #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
485 pub struct Builder {
486 pub(crate) message: std::option::Option<std::string::String>,
487 }
488 impl Builder {
489 #[allow(missing_docs)] pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
491 self.message = Some(input.into());
492 self
493 }
494 #[allow(missing_docs)] pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
496 self.message = input;
497 self
498 }
499 pub fn build(self) -> crate::output::HealthcheckOperationOutput {
501 crate::output::HealthcheckOperationOutput {
502 message: self.message,
503 }
504 }
505 }
506}
507impl HealthcheckOperationOutput {
508 pub fn builder() -> crate::output::healthcheck_operation_output::Builder {
510 crate::output::healthcheck_operation_output::Builder::default()
511 }
512}