render_client/lib.rs
1#[allow(unused_imports)]
2pub use progenitor_client::{ByteStream, ClientInfo, Error, ResponseValue};
3#[allow(unused_imports)]
4use progenitor_client::{ClientHooks, OperationInfo, RequestBuilderExt, encode_path};
5/// Types used as operation parameters and responses.
6#[allow(clippy::all)]
7pub mod types {
8 /// Error types.
9 pub mod error {
10 /// Error from a `TryFrom` or `FromStr` implementation.
11 pub struct ConversionError(::std::borrow::Cow<'static, str>);
12 impl ::std::error::Error for ConversionError {}
13 impl ::std::fmt::Display for ConversionError {
14 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
15 ::std::fmt::Display::fmt(&self.0, f)
16 }
17 }
18
19 impl ::std::fmt::Debug for ConversionError {
20 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
21 ::std::fmt::Debug::fmt(&self.0, f)
22 }
23 }
24
25 impl From<&'static str> for ConversionError {
26 fn from(value: &'static str) -> Self {
27 Self(value.into())
28 }
29 }
30
31 impl From<String> for ConversionError {
32 fn from(value: String) -> Self {
33 Self(value.into())
34 }
35 }
36 }
37
38 ///`AutoDeploy`
39 ///
40 /// <details><summary>JSON schema</summary>
41 ///
42 /// ```json
43 ///{
44 /// "default": "yes",
45 /// "type": "string"
46 ///}
47 /// ```
48 /// </details>
49 #[derive(
50 :: serde :: Deserialize,
51 :: serde :: Serialize,
52 Clone,
53 Debug,
54 Eq,
55 Hash,
56 Ord,
57 PartialEq,
58 PartialOrd,
59 )]
60 #[serde(transparent)]
61 pub struct AutoDeploy(pub ::std::string::String);
62 impl ::std::ops::Deref for AutoDeploy {
63 type Target = ::std::string::String;
64 fn deref(&self) -> &::std::string::String {
65 &self.0
66 }
67 }
68
69 impl ::std::convert::From<AutoDeploy> for ::std::string::String {
70 fn from(value: AutoDeploy) -> Self {
71 value.0
72 }
73 }
74
75 impl ::std::convert::From<::std::string::String> for AutoDeploy {
76 fn from(value: ::std::string::String) -> Self {
77 Self(value)
78 }
79 }
80
81 impl ::std::str::FromStr for AutoDeploy {
82 type Err = ::std::convert::Infallible;
83 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
84 Ok(Self(value.to_string()))
85 }
86 }
87
88 impl ::std::fmt::Display for AutoDeploy {
89 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
90 self.0.fmt(f)
91 }
92 }
93
94 ///`BackgroundWorkerDetails`
95 ///
96 /// <details><summary>JSON schema</summary>
97 ///
98 /// ```json
99 ///{
100 /// "type": "object",
101 /// "properties": {
102 /// "autoscaling": {
103 /// "type": "object",
104 /// "properties": {
105 /// "criteria": {
106 /// "type": "object",
107 /// "properties": {
108 /// "cpu": {
109 /// "type": "object",
110 /// "properties": {
111 /// "enabled": {
112 /// "default": false,
113 /// "type": "boolean"
114 /// },
115 /// "percentage": {
116 /// "description": "Determines when your service will be
117 /// scaled. If the average resource utilization is significantly above/below
118 /// the target, we will increase/decrease the number of instances.\n",
119 /// "type": "integer"
120 /// }
121 /// }
122 /// },
123 /// "memory": {
124 /// "type": "object",
125 /// "properties": {
126 /// "enabled": {
127 /// "default": false,
128 /// "type": "boolean"
129 /// },
130 /// "percentage": {
131 /// "description": "Determines when your service will be
132 /// scaled. If the average resource utilization is significantly above/below
133 /// the target, we will increase/decrease the number of instances.\n",
134 /// "type": "integer"
135 /// }
136 /// }
137 /// }
138 /// }
139 /// },
140 /// "enabled": {
141 /// "default": false,
142 /// "type": "boolean"
143 /// },
144 /// "max": {
145 /// "description": "The maximum number of instances for the
146 /// service",
147 /// "type": "integer"
148 /// },
149 /// "min": {
150 /// "description": "The minimum number of instances for the
151 /// service",
152 /// "type": "integer"
153 /// }
154 /// }
155 /// },
156 /// "buildPlan": {
157 /// "$ref": "#/components/schemas/buildPlan"
158 /// },
159 /// "disk": {
160 /// "type": "object",
161 /// "properties": {
162 /// "id": {
163 /// "examples": [
164 /// "dsk-cph1rs3idesc73a2b2mg"
165 /// ],
166 /// "type": "string",
167 /// "pattern": "^dsk-[0-9a-z]{20}$"
168 /// },
169 /// "mountPath": {
170 /// "type": "string"
171 /// },
172 /// "name": {
173 /// "type": "string"
174 /// },
175 /// "sizeGB": {
176 /// "type": "integer"
177 /// }
178 /// }
179 /// },
180 /// "env": {
181 /// "$ref": "#/components/schemas/serviceEnv"
182 /// },
183 /// "envSpecificDetails": {
184 /// "$ref": "#/components/schemas/envSpecificDetails"
185 /// },
186 /// "maxShutdownDelaySeconds": {
187 /// "$ref": "#/components/schemas/maxShutdownDelaySeconds"
188 /// },
189 /// "numInstances": {
190 /// "description": "For a *manually* scaled service, this is the number
191 /// of instances the service is scaled to. DOES NOT indicate the number of
192 /// running instances for an *autoscaled* service.",
193 /// "type": "integer"
194 /// },
195 /// "parentServer": {
196 /// "$ref": "#/components/schemas/resource"
197 /// },
198 /// "plan": {
199 /// "$ref": "#/components/schemas/plan"
200 /// },
201 /// "previews": {
202 /// "$ref": "#/components/schemas/previews"
203 /// },
204 /// "pullRequestPreviewsEnabled": {
205 /// "$ref": "#/components/schemas/pullRequestPreviewsEnabled"
206 /// },
207 /// "region": {
208 /// "$ref": "#/components/schemas/region"
209 /// },
210 /// "runtime": {
211 /// "$ref": "#/components/schemas/serviceRuntime"
212 /// },
213 /// "sshAddress": {
214 /// "$ref": "#/components/schemas/sshAddress"
215 /// }
216 /// }
217 ///}
218 /// ```
219 /// </details>
220 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
221 pub struct BackgroundWorkerDetails {
222 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
223 pub autoscaling: ::std::option::Option<BackgroundWorkerDetailsAutoscaling>,
224 #[serde(
225 rename = "buildPlan",
226 default,
227 skip_serializing_if = "::std::option::Option::is_none"
228 )]
229 pub build_plan: ::std::option::Option<BuildPlan>,
230 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
231 pub disk: ::std::option::Option<BackgroundWorkerDetailsDisk>,
232 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
233 pub env: ::std::option::Option<ServiceEnv>,
234 #[serde(
235 rename = "envSpecificDetails",
236 default,
237 skip_serializing_if = "::std::option::Option::is_none"
238 )]
239 pub env_specific_details: ::std::option::Option<EnvSpecificDetails>,
240 #[serde(
241 rename = "maxShutdownDelaySeconds",
242 default,
243 skip_serializing_if = "::std::option::Option::is_none"
244 )]
245 pub max_shutdown_delay_seconds: ::std::option::Option<MaxShutdownDelaySeconds>,
246 ///For a *manually* scaled service, this is the number of instances the
247 /// service is scaled to. DOES NOT indicate the number of running
248 /// instances for an *autoscaled* service.
249 #[serde(
250 rename = "numInstances",
251 default,
252 skip_serializing_if = "::std::option::Option::is_none"
253 )]
254 pub num_instances: ::std::option::Option<i64>,
255 #[serde(
256 rename = "parentServer",
257 default,
258 skip_serializing_if = "::std::option::Option::is_none"
259 )]
260 pub parent_server: ::std::option::Option<Resource>,
261 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
262 pub plan: ::std::option::Option<Plan>,
263 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
264 pub previews: ::std::option::Option<Previews>,
265 #[serde(
266 rename = "pullRequestPreviewsEnabled",
267 default,
268 skip_serializing_if = "::std::option::Option::is_none"
269 )]
270 pub pull_request_previews_enabled: ::std::option::Option<PullRequestPreviewsEnabled>,
271 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
272 pub region: ::std::option::Option<Region>,
273 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
274 pub runtime: ::std::option::Option<ServiceRuntime>,
275 #[serde(
276 rename = "sshAddress",
277 default,
278 skip_serializing_if = "::std::option::Option::is_none"
279 )]
280 pub ssh_address: ::std::option::Option<SshAddress>,
281 }
282
283 impl ::std::default::Default for BackgroundWorkerDetails {
284 fn default() -> Self {
285 Self {
286 autoscaling: Default::default(),
287 build_plan: Default::default(),
288 disk: Default::default(),
289 env: Default::default(),
290 env_specific_details: Default::default(),
291 max_shutdown_delay_seconds: Default::default(),
292 num_instances: Default::default(),
293 parent_server: Default::default(),
294 plan: Default::default(),
295 previews: Default::default(),
296 pull_request_previews_enabled: Default::default(),
297 region: Default::default(),
298 runtime: Default::default(),
299 ssh_address: Default::default(),
300 }
301 }
302 }
303
304 ///`BackgroundWorkerDetailsAutoscaling`
305 ///
306 /// <details><summary>JSON schema</summary>
307 ///
308 /// ```json
309 ///{
310 /// "type": "object",
311 /// "properties": {
312 /// "criteria": {
313 /// "type": "object",
314 /// "properties": {
315 /// "cpu": {
316 /// "type": "object",
317 /// "properties": {
318 /// "enabled": {
319 /// "default": false,
320 /// "type": "boolean"
321 /// },
322 /// "percentage": {
323 /// "description": "Determines when your service will be
324 /// scaled. If the average resource utilization is significantly above/below
325 /// the target, we will increase/decrease the number of instances.\n",
326 /// "type": "integer"
327 /// }
328 /// }
329 /// },
330 /// "memory": {
331 /// "type": "object",
332 /// "properties": {
333 /// "enabled": {
334 /// "default": false,
335 /// "type": "boolean"
336 /// },
337 /// "percentage": {
338 /// "description": "Determines when your service will be
339 /// scaled. If the average resource utilization is significantly above/below
340 /// the target, we will increase/decrease the number of instances.\n",
341 /// "type": "integer"
342 /// }
343 /// }
344 /// }
345 /// }
346 /// },
347 /// "enabled": {
348 /// "default": false,
349 /// "type": "boolean"
350 /// },
351 /// "max": {
352 /// "description": "The maximum number of instances for the service",
353 /// "type": "integer"
354 /// },
355 /// "min": {
356 /// "description": "The minimum number of instances for the service",
357 /// "type": "integer"
358 /// }
359 /// }
360 ///}
361 /// ```
362 /// </details>
363 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
364 pub struct BackgroundWorkerDetailsAutoscaling {
365 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
366 pub criteria: ::std::option::Option<BackgroundWorkerDetailsAutoscalingCriteria>,
367 #[serde(default)]
368 pub enabled: bool,
369 ///The maximum number of instances for the service
370 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
371 pub max: ::std::option::Option<i64>,
372 ///The minimum number of instances for the service
373 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
374 pub min: ::std::option::Option<i64>,
375 }
376
377 impl ::std::default::Default for BackgroundWorkerDetailsAutoscaling {
378 fn default() -> Self {
379 Self {
380 criteria: Default::default(),
381 enabled: Default::default(),
382 max: Default::default(),
383 min: Default::default(),
384 }
385 }
386 }
387
388 ///`BackgroundWorkerDetailsAutoscalingCriteria`
389 ///
390 /// <details><summary>JSON schema</summary>
391 ///
392 /// ```json
393 ///{
394 /// "type": "object",
395 /// "properties": {
396 /// "cpu": {
397 /// "type": "object",
398 /// "properties": {
399 /// "enabled": {
400 /// "default": false,
401 /// "type": "boolean"
402 /// },
403 /// "percentage": {
404 /// "description": "Determines when your service will be scaled. If
405 /// the average resource utilization is significantly above/below the
406 /// target, we will increase/decrease the number of instances.\n",
407 /// "type": "integer"
408 /// }
409 /// }
410 /// },
411 /// "memory": {
412 /// "type": "object",
413 /// "properties": {
414 /// "enabled": {
415 /// "default": false,
416 /// "type": "boolean"
417 /// },
418 /// "percentage": {
419 /// "description": "Determines when your service will be scaled. If
420 /// the average resource utilization is significantly above/below the
421 /// target, we will increase/decrease the number of instances.\n",
422 /// "type": "integer"
423 /// }
424 /// }
425 /// }
426 /// }
427 ///}
428 /// ```
429 /// </details>
430 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
431 pub struct BackgroundWorkerDetailsAutoscalingCriteria {
432 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
433 pub cpu: ::std::option::Option<BackgroundWorkerDetailsAutoscalingCriteriaCpu>,
434 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
435 pub memory: ::std::option::Option<BackgroundWorkerDetailsAutoscalingCriteriaMemory>,
436 }
437
438 impl ::std::default::Default for BackgroundWorkerDetailsAutoscalingCriteria {
439 fn default() -> Self {
440 Self {
441 cpu: Default::default(),
442 memory: Default::default(),
443 }
444 }
445 }
446
447 ///`BackgroundWorkerDetailsAutoscalingCriteriaCpu`
448 ///
449 /// <details><summary>JSON schema</summary>
450 ///
451 /// ```json
452 ///{
453 /// "type": "object",
454 /// "properties": {
455 /// "enabled": {
456 /// "default": false,
457 /// "type": "boolean"
458 /// },
459 /// "percentage": {
460 /// "description": "Determines when your service will be scaled. If the
461 /// average resource utilization is significantly above/below the target, we
462 /// will increase/decrease the number of instances.\n",
463 /// "type": "integer"
464 /// }
465 /// }
466 ///}
467 /// ```
468 /// </details>
469 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
470 pub struct BackgroundWorkerDetailsAutoscalingCriteriaCpu {
471 #[serde(default)]
472 pub enabled: bool,
473 ///Determines when your service will be scaled. If the average resource
474 /// utilization is significantly above/below the target, we will
475 /// increase/decrease the number of instances.
476 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
477 pub percentage: ::std::option::Option<i64>,
478 }
479
480 impl ::std::default::Default for BackgroundWorkerDetailsAutoscalingCriteriaCpu {
481 fn default() -> Self {
482 Self {
483 enabled: Default::default(),
484 percentage: Default::default(),
485 }
486 }
487 }
488
489 ///`BackgroundWorkerDetailsAutoscalingCriteriaMemory`
490 ///
491 /// <details><summary>JSON schema</summary>
492 ///
493 /// ```json
494 ///{
495 /// "type": "object",
496 /// "properties": {
497 /// "enabled": {
498 /// "default": false,
499 /// "type": "boolean"
500 /// },
501 /// "percentage": {
502 /// "description": "Determines when your service will be scaled. If the
503 /// average resource utilization is significantly above/below the target, we
504 /// will increase/decrease the number of instances.\n",
505 /// "type": "integer"
506 /// }
507 /// }
508 ///}
509 /// ```
510 /// </details>
511 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
512 pub struct BackgroundWorkerDetailsAutoscalingCriteriaMemory {
513 #[serde(default)]
514 pub enabled: bool,
515 ///Determines when your service will be scaled. If the average resource
516 /// utilization is significantly above/below the target, we will
517 /// increase/decrease the number of instances.
518 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
519 pub percentage: ::std::option::Option<i64>,
520 }
521
522 impl ::std::default::Default for BackgroundWorkerDetailsAutoscalingCriteriaMemory {
523 fn default() -> Self {
524 Self {
525 enabled: Default::default(),
526 percentage: Default::default(),
527 }
528 }
529 }
530
531 ///`BackgroundWorkerDetailsDisk`
532 ///
533 /// <details><summary>JSON schema</summary>
534 ///
535 /// ```json
536 ///{
537 /// "type": "object",
538 /// "properties": {
539 /// "id": {
540 /// "examples": [
541 /// "dsk-cph1rs3idesc73a2b2mg"
542 /// ],
543 /// "type": "string",
544 /// "pattern": "^dsk-[0-9a-z]{20}$"
545 /// },
546 /// "mountPath": {
547 /// "type": "string"
548 /// },
549 /// "name": {
550 /// "type": "string"
551 /// },
552 /// "sizeGB": {
553 /// "type": "integer"
554 /// }
555 /// }
556 ///}
557 /// ```
558 /// </details>
559 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
560 pub struct BackgroundWorkerDetailsDisk {
561 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
562 pub id: ::std::option::Option<BackgroundWorkerDetailsDiskId>,
563 #[serde(
564 rename = "mountPath",
565 default,
566 skip_serializing_if = "::std::option::Option::is_none"
567 )]
568 pub mount_path: ::std::option::Option<::std::string::String>,
569 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
570 pub name: ::std::option::Option<::std::string::String>,
571 #[serde(
572 rename = "sizeGB",
573 default,
574 skip_serializing_if = "::std::option::Option::is_none"
575 )]
576 pub size_gb: ::std::option::Option<i64>,
577 }
578
579 impl ::std::default::Default for BackgroundWorkerDetailsDisk {
580 fn default() -> Self {
581 Self {
582 id: Default::default(),
583 mount_path: Default::default(),
584 name: Default::default(),
585 size_gb: Default::default(),
586 }
587 }
588 }
589
590 ///`BackgroundWorkerDetailsDiskId`
591 ///
592 /// <details><summary>JSON schema</summary>
593 ///
594 /// ```json
595 ///{
596 /// "examples": [
597 /// "dsk-cph1rs3idesc73a2b2mg"
598 /// ],
599 /// "type": "string",
600 /// "pattern": "^dsk-[0-9a-z]{20}$"
601 ///}
602 /// ```
603 /// </details>
604 #[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
605 #[serde(transparent)]
606 pub struct BackgroundWorkerDetailsDiskId(::std::string::String);
607 impl ::std::ops::Deref for BackgroundWorkerDetailsDiskId {
608 type Target = ::std::string::String;
609 fn deref(&self) -> &::std::string::String {
610 &self.0
611 }
612 }
613
614 impl ::std::convert::From<BackgroundWorkerDetailsDiskId> for ::std::string::String {
615 fn from(value: BackgroundWorkerDetailsDiskId) -> Self {
616 value.0
617 }
618 }
619
620 impl ::std::str::FromStr for BackgroundWorkerDetailsDiskId {
621 type Err = self::error::ConversionError;
622 fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
623 static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
624 ::std::sync::LazyLock::new(|| ::regress::Regex::new("^dsk-[0-9a-z]{20}$").unwrap());
625 if PATTERN.find(value).is_none() {
626 return Err("doesn't match pattern \"^dsk-[0-9a-z]{20}$\"".into());
627 }
628 Ok(Self(value.to_string()))
629 }
630 }
631
632 impl ::std::convert::TryFrom<&str> for BackgroundWorkerDetailsDiskId {
633 type Error = self::error::ConversionError;
634 fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
635 value.parse()
636 }
637 }
638
639 impl ::std::convert::TryFrom<&::std::string::String> for BackgroundWorkerDetailsDiskId {
640 type Error = self::error::ConversionError;
641 fn try_from(
642 value: &::std::string::String,
643 ) -> ::std::result::Result<Self, self::error::ConversionError> {
644 value.parse()
645 }
646 }
647
648 impl ::std::convert::TryFrom<::std::string::String> for BackgroundWorkerDetailsDiskId {
649 type Error = self::error::ConversionError;
650 fn try_from(
651 value: ::std::string::String,
652 ) -> ::std::result::Result<Self, self::error::ConversionError> {
653 value.parse()
654 }
655 }
656
657 impl<'de> ::serde::Deserialize<'de> for BackgroundWorkerDetailsDiskId {
658 fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
659 where
660 D: ::serde::Deserializer<'de>,
661 {
662 ::std::string::String::deserialize(deserializer)?
663 .parse()
664 .map_err(|e: self::error::ConversionError| {
665 <D::Error as ::serde::de::Error>::custom(e.to_string())
666 })
667 }
668 }
669
670 ///`BackgroundWorkerDetailsPost`
671 ///
672 /// <details><summary>JSON schema</summary>
673 ///
674 /// ```json
675 ///{
676 /// "type": "object",
677 /// "properties": {
678 /// "autoscaling": {
679 /// "type": "object",
680 /// "properties": {
681 /// "criteria": {
682 /// "type": "object",
683 /// "properties": {
684 /// "cpu": {
685 /// "type": "object",
686 /// "properties": {
687 /// "enabled": {
688 /// "default": false,
689 /// "type": "boolean"
690 /// },
691 /// "percentage": {
692 /// "description": "Determines when your service will be
693 /// scaled. If the average resource utilization is significantly above/below
694 /// the target, we will increase/decrease the number of instances.\n",
695 /// "type": "integer"
696 /// }
697 /// }
698 /// },
699 /// "memory": {
700 /// "type": "object",
701 /// "properties": {
702 /// "enabled": {
703 /// "default": false,
704 /// "type": "boolean"
705 /// },
706 /// "percentage": {
707 /// "description": "Determines when your service will be
708 /// scaled. If the average resource utilization is significantly above/below
709 /// the target, we will increase/decrease the number of instances.\n",
710 /// "type": "integer"
711 /// }
712 /// }
713 /// }
714 /// }
715 /// },
716 /// "enabled": {
717 /// "default": false,
718 /// "type": "boolean"
719 /// },
720 /// "max": {
721 /// "description": "The maximum number of instances for the
722 /// service",
723 /// "type": "integer"
724 /// },
725 /// "min": {
726 /// "description": "The minimum number of instances for the
727 /// service",
728 /// "type": "integer"
729 /// }
730 /// }
731 /// },
732 /// "disk": {
733 /// "$ref": "#/components/schemas/serviceDisk"
734 /// },
735 /// "env": {
736 /// "$ref": "#/components/schemas/serviceEnv"
737 /// },
738 /// "envSpecificDetails": {
739 /// "$ref": "#/components/schemas/envSpecificDetailsPOST"
740 /// },
741 /// "maxShutdownDelaySeconds": {
742 /// "$ref": "#/components/schemas/maxShutdownDelaySeconds"
743 /// },
744 /// "numInstances": {
745 /// "description": "Defaults to 1",
746 /// "default": 1,
747 /// "type": "integer",
748 /// "minimum": 1.0
749 /// },
750 /// "plan": {
751 /// "$ref": "#/components/schemas/paidPlan"
752 /// },
753 /// "preDeployCommand": {
754 /// "type": "string"
755 /// },
756 /// "previews": {
757 /// "$ref": "#/components/schemas/previews"
758 /// },
759 /// "pullRequestPreviewsEnabled": {
760 /// "$ref": "#/components/schemas/pullRequestPreviewsEnabled"
761 /// },
762 /// "region": {
763 /// "$ref": "#/components/schemas/region"
764 /// },
765 /// "runtime": {
766 /// "$ref": "#/components/schemas/serviceRuntime"
767 /// }
768 /// }
769 ///}
770 /// ```
771 /// </details>
772 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
773 pub struct BackgroundWorkerDetailsPost {
774 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
775 pub autoscaling: ::std::option::Option<BackgroundWorkerDetailsPostAutoscaling>,
776 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
777 pub disk: ::std::option::Option<ServiceDisk>,
778 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
779 pub env: ::std::option::Option<ServiceEnv>,
780 #[serde(
781 rename = "envSpecificDetails",
782 default,
783 skip_serializing_if = "::std::option::Option::is_none"
784 )]
785 pub env_specific_details: ::std::option::Option<EnvSpecificDetailsPost>,
786 #[serde(
787 rename = "maxShutdownDelaySeconds",
788 default,
789 skip_serializing_if = "::std::option::Option::is_none"
790 )]
791 pub max_shutdown_delay_seconds: ::std::option::Option<MaxShutdownDelaySeconds>,
792 ///Defaults to 1
793 #[serde(
794 rename = "numInstances",
795 default = "defaults::default_nzu64::<::std::num::NonZeroU64, 1>"
796 )]
797 pub num_instances: ::std::num::NonZeroU64,
798 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
799 pub plan: ::std::option::Option<PaidPlan>,
800 #[serde(
801 rename = "preDeployCommand",
802 default,
803 skip_serializing_if = "::std::option::Option::is_none"
804 )]
805 pub pre_deploy_command: ::std::option::Option<::std::string::String>,
806 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
807 pub previews: ::std::option::Option<Previews>,
808 #[serde(
809 rename = "pullRequestPreviewsEnabled",
810 default,
811 skip_serializing_if = "::std::option::Option::is_none"
812 )]
813 pub pull_request_previews_enabled: ::std::option::Option<PullRequestPreviewsEnabled>,
814 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
815 pub region: ::std::option::Option<Region>,
816 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
817 pub runtime: ::std::option::Option<ServiceRuntime>,
818 }
819
820 impl ::std::default::Default for BackgroundWorkerDetailsPost {
821 fn default() -> Self {
822 Self {
823 autoscaling: Default::default(),
824 disk: Default::default(),
825 env: Default::default(),
826 env_specific_details: Default::default(),
827 max_shutdown_delay_seconds: Default::default(),
828 num_instances: defaults::default_nzu64::<::std::num::NonZeroU64, 1>(),
829 plan: Default::default(),
830 pre_deploy_command: Default::default(),
831 previews: Default::default(),
832 pull_request_previews_enabled: Default::default(),
833 region: Default::default(),
834 runtime: Default::default(),
835 }
836 }
837 }
838
839 ///`BackgroundWorkerDetailsPostAutoscaling`
840 ///
841 /// <details><summary>JSON schema</summary>
842 ///
843 /// ```json
844 ///{
845 /// "type": "object",
846 /// "properties": {
847 /// "criteria": {
848 /// "type": "object",
849 /// "properties": {
850 /// "cpu": {
851 /// "type": "object",
852 /// "properties": {
853 /// "enabled": {
854 /// "default": false,
855 /// "type": "boolean"
856 /// },
857 /// "percentage": {
858 /// "description": "Determines when your service will be
859 /// scaled. If the average resource utilization is significantly above/below
860 /// the target, we will increase/decrease the number of instances.\n",
861 /// "type": "integer"
862 /// }
863 /// }
864 /// },
865 /// "memory": {
866 /// "type": "object",
867 /// "properties": {
868 /// "enabled": {
869 /// "default": false,
870 /// "type": "boolean"
871 /// },
872 /// "percentage": {
873 /// "description": "Determines when your service will be
874 /// scaled. If the average resource utilization is significantly above/below
875 /// the target, we will increase/decrease the number of instances.\n",
876 /// "type": "integer"
877 /// }
878 /// }
879 /// }
880 /// }
881 /// },
882 /// "enabled": {
883 /// "default": false,
884 /// "type": "boolean"
885 /// },
886 /// "max": {
887 /// "description": "The maximum number of instances for the service",
888 /// "type": "integer"
889 /// },
890 /// "min": {
891 /// "description": "The minimum number of instances for the service",
892 /// "type": "integer"
893 /// }
894 /// }
895 ///}
896 /// ```
897 /// </details>
898 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
899 pub struct BackgroundWorkerDetailsPostAutoscaling {
900 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
901 pub criteria: ::std::option::Option<BackgroundWorkerDetailsPostAutoscalingCriteria>,
902 #[serde(default)]
903 pub enabled: bool,
904 ///The maximum number of instances for the service
905 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
906 pub max: ::std::option::Option<i64>,
907 ///The minimum number of instances for the service
908 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
909 pub min: ::std::option::Option<i64>,
910 }
911
912 impl ::std::default::Default for BackgroundWorkerDetailsPostAutoscaling {
913 fn default() -> Self {
914 Self {
915 criteria: Default::default(),
916 enabled: Default::default(),
917 max: Default::default(),
918 min: Default::default(),
919 }
920 }
921 }
922
923 ///`BackgroundWorkerDetailsPostAutoscalingCriteria`
924 ///
925 /// <details><summary>JSON schema</summary>
926 ///
927 /// ```json
928 ///{
929 /// "type": "object",
930 /// "properties": {
931 /// "cpu": {
932 /// "type": "object",
933 /// "properties": {
934 /// "enabled": {
935 /// "default": false,
936 /// "type": "boolean"
937 /// },
938 /// "percentage": {
939 /// "description": "Determines when your service will be scaled. If
940 /// the average resource utilization is significantly above/below the
941 /// target, we will increase/decrease the number of instances.\n",
942 /// "type": "integer"
943 /// }
944 /// }
945 /// },
946 /// "memory": {
947 /// "type": "object",
948 /// "properties": {
949 /// "enabled": {
950 /// "default": false,
951 /// "type": "boolean"
952 /// },
953 /// "percentage": {
954 /// "description": "Determines when your service will be scaled. If
955 /// the average resource utilization is significantly above/below the
956 /// target, we will increase/decrease the number of instances.\n",
957 /// "type": "integer"
958 /// }
959 /// }
960 /// }
961 /// }
962 ///}
963 /// ```
964 /// </details>
965 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
966 pub struct BackgroundWorkerDetailsPostAutoscalingCriteria {
967 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
968 pub cpu: ::std::option::Option<BackgroundWorkerDetailsPostAutoscalingCriteriaCpu>,
969 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
970 pub memory: ::std::option::Option<BackgroundWorkerDetailsPostAutoscalingCriteriaMemory>,
971 }
972
973 impl ::std::default::Default for BackgroundWorkerDetailsPostAutoscalingCriteria {
974 fn default() -> Self {
975 Self {
976 cpu: Default::default(),
977 memory: Default::default(),
978 }
979 }
980 }
981
982 ///`BackgroundWorkerDetailsPostAutoscalingCriteriaCpu`
983 ///
984 /// <details><summary>JSON schema</summary>
985 ///
986 /// ```json
987 ///{
988 /// "type": "object",
989 /// "properties": {
990 /// "enabled": {
991 /// "default": false,
992 /// "type": "boolean"
993 /// },
994 /// "percentage": {
995 /// "description": "Determines when your service will be scaled. If the
996 /// average resource utilization is significantly above/below the target, we
997 /// will increase/decrease the number of instances.\n",
998 /// "type": "integer"
999 /// }
1000 /// }
1001 ///}
1002 /// ```
1003 /// </details>
1004 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1005 pub struct BackgroundWorkerDetailsPostAutoscalingCriteriaCpu {
1006 #[serde(default)]
1007 pub enabled: bool,
1008 ///Determines when your service will be scaled. If the average resource
1009 /// utilization is significantly above/below the target, we will
1010 /// increase/decrease the number of instances.
1011 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1012 pub percentage: ::std::option::Option<i64>,
1013 }
1014
1015 impl ::std::default::Default for BackgroundWorkerDetailsPostAutoscalingCriteriaCpu {
1016 fn default() -> Self {
1017 Self {
1018 enabled: Default::default(),
1019 percentage: Default::default(),
1020 }
1021 }
1022 }
1023
1024 ///`BackgroundWorkerDetailsPostAutoscalingCriteriaMemory`
1025 ///
1026 /// <details><summary>JSON schema</summary>
1027 ///
1028 /// ```json
1029 ///{
1030 /// "type": "object",
1031 /// "properties": {
1032 /// "enabled": {
1033 /// "default": false,
1034 /// "type": "boolean"
1035 /// },
1036 /// "percentage": {
1037 /// "description": "Determines when your service will be scaled. If the
1038 /// average resource utilization is significantly above/below the target, we
1039 /// will increase/decrease the number of instances.\n",
1040 /// "type": "integer"
1041 /// }
1042 /// }
1043 ///}
1044 /// ```
1045 /// </details>
1046 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1047 pub struct BackgroundWorkerDetailsPostAutoscalingCriteriaMemory {
1048 #[serde(default)]
1049 pub enabled: bool,
1050 ///Determines when your service will be scaled. If the average resource
1051 /// utilization is significantly above/below the target, we will
1052 /// increase/decrease the number of instances.
1053 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1054 pub percentage: ::std::option::Option<i64>,
1055 }
1056
1057 impl ::std::default::Default for BackgroundWorkerDetailsPostAutoscalingCriteriaMemory {
1058 fn default() -> Self {
1059 Self {
1060 enabled: Default::default(),
1061 percentage: Default::default(),
1062 }
1063 }
1064 }
1065
1066 ///`BuildFilter`
1067 ///
1068 /// <details><summary>JSON schema</summary>
1069 ///
1070 /// ```json
1071 ///{
1072 /// "type": "object",
1073 /// "properties": {
1074 /// "ignoredPaths": {
1075 /// "type": "array",
1076 /// "items": {
1077 /// "type": "string"
1078 /// }
1079 /// },
1080 /// "paths": {
1081 /// "type": "array",
1082 /// "items": {
1083 /// "type": "string"
1084 /// }
1085 /// }
1086 /// }
1087 ///}
1088 /// ```
1089 /// </details>
1090 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1091 pub struct BuildFilter {
1092 #[serde(
1093 rename = "ignoredPaths",
1094 default,
1095 skip_serializing_if = "::std::vec::Vec::is_empty"
1096 )]
1097 pub ignored_paths: ::std::vec::Vec<::std::string::String>,
1098 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
1099 pub paths: ::std::vec::Vec<::std::string::String>,
1100 }
1101
1102 impl ::std::default::Default for BuildFilter {
1103 fn default() -> Self {
1104 Self {
1105 ignored_paths: Default::default(),
1106 paths: Default::default(),
1107 }
1108 }
1109 }
1110
1111 ///`BuildPlan`
1112 ///
1113 /// <details><summary>JSON schema</summary>
1114 ///
1115 /// ```json
1116 ///{
1117 /// "default": "starter",
1118 /// "type": "string"
1119 ///}
1120 /// ```
1121 /// </details>
1122 #[derive(
1123 :: serde :: Deserialize,
1124 :: serde :: Serialize,
1125 Clone,
1126 Debug,
1127 Eq,
1128 Hash,
1129 Ord,
1130 PartialEq,
1131 PartialOrd,
1132 )]
1133 #[serde(transparent)]
1134 pub struct BuildPlan(pub ::std::string::String);
1135 impl ::std::ops::Deref for BuildPlan {
1136 type Target = ::std::string::String;
1137 fn deref(&self) -> &::std::string::String {
1138 &self.0
1139 }
1140 }
1141
1142 impl ::std::convert::From<BuildPlan> for ::std::string::String {
1143 fn from(value: BuildPlan) -> Self {
1144 value.0
1145 }
1146 }
1147
1148 impl ::std::convert::From<::std::string::String> for BuildPlan {
1149 fn from(value: ::std::string::String) -> Self {
1150 Self(value)
1151 }
1152 }
1153
1154 impl ::std::str::FromStr for BuildPlan {
1155 type Err = ::std::convert::Infallible;
1156 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
1157 Ok(Self(value.to_string()))
1158 }
1159 }
1160
1161 impl ::std::fmt::Display for BuildPlan {
1162 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1163 self.0.fmt(f)
1164 }
1165 }
1166
1167 ///`Cache`
1168 ///
1169 /// <details><summary>JSON schema</summary>
1170 ///
1171 /// ```json
1172 ///{
1173 /// "type": "object",
1174 /// "properties": {
1175 /// "profile": {
1176 /// "default": "no-cache",
1177 /// "type": "string"
1178 /// }
1179 /// }
1180 ///}
1181 /// ```
1182 /// </details>
1183 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1184 pub struct Cache {
1185 #[serde(default = "defaults::cache_profile")]
1186 pub profile: ::std::string::String,
1187 }
1188
1189 impl ::std::default::Default for Cache {
1190 fn default() -> Self {
1191 Self {
1192 profile: defaults::cache_profile(),
1193 }
1194 }
1195 }
1196
1197 ///`CidrBlockAndDescription`
1198 ///
1199 /// <details><summary>JSON schema</summary>
1200 ///
1201 /// ```json
1202 ///{
1203 /// "type": "object",
1204 /// "properties": {
1205 /// "cidrBlock": {
1206 /// "type": "string"
1207 /// },
1208 /// "description": {
1209 /// "description": "User-provided description of the CIDR block",
1210 /// "type": "string"
1211 /// }
1212 /// }
1213 ///}
1214 /// ```
1215 /// </details>
1216 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1217 pub struct CidrBlockAndDescription {
1218 #[serde(
1219 rename = "cidrBlock",
1220 default,
1221 skip_serializing_if = "::std::option::Option::is_none"
1222 )]
1223 pub cidr_block: ::std::option::Option<::std::string::String>,
1224 ///User-provided description of the CIDR block
1225 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1226 pub description: ::std::option::Option<::std::string::String>,
1227 }
1228
1229 impl ::std::default::Default for CidrBlockAndDescription {
1230 fn default() -> Self {
1231 Self {
1232 cidr_block: Default::default(),
1233 description: Default::default(),
1234 }
1235 }
1236 }
1237
1238 ///`CreateDeployBody`
1239 ///
1240 /// <details><summary>JSON schema</summary>
1241 ///
1242 /// ```json
1243 ///{
1244 /// "type": "object",
1245 /// "properties": {
1246 /// "clearCache": {
1247 /// "description": "If `clear`, Render clears the service's build cache
1248 /// before deploying. This can be useful if you're experiencing issues with
1249 /// your build.",
1250 /// "default": "do_not_clear",
1251 /// "type": "string"
1252 /// },
1253 /// "commitId": {
1254 /// "description": "The SHA of a specific Git commit to deploy for a service. Defaults to the latest commit on the service's connected branch.\n\nNote that deploying a specific commit with this endpoint does not disable autodeploys for the service.\n\nYou can toggle autodeploys for your service with the [Update service](https://api-docs.render.com/reference/update-service) endpoint or in the Render Dashboard.\n\nNot supported for cron jobs.\n",
1255 /// "type": "string"
1256 /// },
1257 /// "deployMode": {
1258 /// "$ref": "#/components/schemas/DeployMode"
1259 /// },
1260 /// "imageUrl": {
1261 /// "description": "The URL of the image to deploy for an image-backed
1262 /// service.\n\nThe host, repository, and image name all must match the
1263 /// currently configured image for the service.\n",
1264 /// "type": "string"
1265 /// }
1266 /// }
1267 ///}
1268 /// ```
1269 /// </details>
1270 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1271 pub struct CreateDeployBody {
1272 ///If `clear`, Render clears the service's build cache before
1273 /// deploying. This can be useful if you're experiencing issues with
1274 /// your build.
1275 #[serde(
1276 rename = "clearCache",
1277 default = "defaults::create_deploy_body_clear_cache"
1278 )]
1279 pub clear_cache: ::std::string::String,
1280 ///The SHA of a specific Git commit to deploy for a service. Defaults
1281 /// to the latest commit on the service's connected branch.
1282 ///
1283 ///Note that deploying a specific commit with this endpoint does not
1284 /// disable autodeploys for the service.
1285 ///
1286 ///You can toggle autodeploys for your service with the [Update service](https://api-docs.render.com/reference/update-service) endpoint or in the Render Dashboard.
1287 ///
1288 ///Not supported for cron jobs.
1289 #[serde(
1290 rename = "commitId",
1291 default,
1292 skip_serializing_if = "::std::option::Option::is_none"
1293 )]
1294 pub commit_id: ::std::option::Option<::std::string::String>,
1295 #[serde(
1296 rename = "deployMode",
1297 default,
1298 skip_serializing_if = "::std::option::Option::is_none"
1299 )]
1300 pub deploy_mode: ::std::option::Option<DeployMode>,
1301 ///The URL of the image to deploy for an image-backed service.
1302 ///
1303 ///The host, repository, and image name all must match the currently
1304 /// configured image for the service.
1305 #[serde(
1306 rename = "imageUrl",
1307 default,
1308 skip_serializing_if = "::std::option::Option::is_none"
1309 )]
1310 pub image_url: ::std::option::Option<::std::string::String>,
1311 }
1312
1313 impl ::std::default::Default for CreateDeployBody {
1314 fn default() -> Self {
1315 Self {
1316 clear_cache: defaults::create_deploy_body_clear_cache(),
1317 commit_id: Default::default(),
1318 deploy_mode: Default::default(),
1319 image_url: Default::default(),
1320 }
1321 }
1322 }
1323
1324 ///`CronJobDetails`
1325 ///
1326 /// <details><summary>JSON schema</summary>
1327 ///
1328 /// ```json
1329 ///{
1330 /// "type": "object",
1331 /// "properties": {
1332 /// "buildPlan": {
1333 /// "$ref": "#/components/schemas/buildPlan"
1334 /// },
1335 /// "env": {
1336 /// "$ref": "#/components/schemas/serviceEnv"
1337 /// },
1338 /// "envSpecificDetails": {
1339 /// "$ref": "#/components/schemas/envSpecificDetails"
1340 /// },
1341 /// "lastSuccessfulRunAt": {
1342 /// "type": "string",
1343 /// "format": "date-time"
1344 /// },
1345 /// "plan": {
1346 /// "$ref": "#/components/schemas/plan"
1347 /// },
1348 /// "region": {
1349 /// "$ref": "#/components/schemas/region"
1350 /// },
1351 /// "runtime": {
1352 /// "$ref": "#/components/schemas/serviceRuntime"
1353 /// },
1354 /// "schedule": {
1355 /// "type": "string"
1356 /// }
1357 /// }
1358 ///}
1359 /// ```
1360 /// </details>
1361 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1362 pub struct CronJobDetails {
1363 #[serde(
1364 rename = "buildPlan",
1365 default,
1366 skip_serializing_if = "::std::option::Option::is_none"
1367 )]
1368 pub build_plan: ::std::option::Option<BuildPlan>,
1369 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1370 pub env: ::std::option::Option<ServiceEnv>,
1371 #[serde(
1372 rename = "envSpecificDetails",
1373 default,
1374 skip_serializing_if = "::std::option::Option::is_none"
1375 )]
1376 pub env_specific_details: ::std::option::Option<EnvSpecificDetails>,
1377 #[serde(
1378 rename = "lastSuccessfulRunAt",
1379 default,
1380 skip_serializing_if = "::std::option::Option::is_none"
1381 )]
1382 pub last_successful_run_at:
1383 ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
1384 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1385 pub plan: ::std::option::Option<Plan>,
1386 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1387 pub region: ::std::option::Option<Region>,
1388 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1389 pub runtime: ::std::option::Option<ServiceRuntime>,
1390 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1391 pub schedule: ::std::option::Option<::std::string::String>,
1392 }
1393
1394 impl ::std::default::Default for CronJobDetails {
1395 fn default() -> Self {
1396 Self {
1397 build_plan: Default::default(),
1398 env: Default::default(),
1399 env_specific_details: Default::default(),
1400 last_successful_run_at: Default::default(),
1401 plan: Default::default(),
1402 region: Default::default(),
1403 runtime: Default::default(),
1404 schedule: Default::default(),
1405 }
1406 }
1407 }
1408
1409 ///`CronJobDetailsPost`
1410 ///
1411 /// <details><summary>JSON schema</summary>
1412 ///
1413 /// ```json
1414 ///{
1415 /// "type": "object",
1416 /// "properties": {
1417 /// "env": {
1418 /// "$ref": "#/components/schemas/serviceEnv"
1419 /// },
1420 /// "envSpecificDetails": {
1421 /// "$ref": "#/components/schemas/envSpecificDetails"
1422 /// },
1423 /// "plan": {
1424 /// "$ref": "#/components/schemas/paidPlan"
1425 /// },
1426 /// "region": {
1427 /// "$ref": "#/components/schemas/region"
1428 /// },
1429 /// "runtime": {
1430 /// "$ref": "#/components/schemas/serviceRuntime"
1431 /// },
1432 /// "schedule": {
1433 /// "type": "string"
1434 /// }
1435 /// }
1436 ///}
1437 /// ```
1438 /// </details>
1439 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1440 pub struct CronJobDetailsPost {
1441 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1442 pub env: ::std::option::Option<ServiceEnv>,
1443 #[serde(
1444 rename = "envSpecificDetails",
1445 default,
1446 skip_serializing_if = "::std::option::Option::is_none"
1447 )]
1448 pub env_specific_details: ::std::option::Option<EnvSpecificDetails>,
1449 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1450 pub plan: ::std::option::Option<PaidPlan>,
1451 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1452 pub region: ::std::option::Option<Region>,
1453 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1454 pub runtime: ::std::option::Option<ServiceRuntime>,
1455 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1456 pub schedule: ::std::option::Option<::std::string::String>,
1457 }
1458
1459 impl ::std::default::Default for CronJobDetailsPost {
1460 fn default() -> Self {
1461 Self {
1462 env: Default::default(),
1463 env_specific_details: Default::default(),
1464 plan: Default::default(),
1465 region: Default::default(),
1466 runtime: Default::default(),
1467 schedule: Default::default(),
1468 }
1469 }
1470 }
1471
1472 ///`Cursor`
1473 ///
1474 /// <details><summary>JSON schema</summary>
1475 ///
1476 /// ```json
1477 ///{
1478 /// "type": "string"
1479 ///}
1480 /// ```
1481 /// </details>
1482 #[derive(
1483 :: serde :: Deserialize,
1484 :: serde :: Serialize,
1485 Clone,
1486 Debug,
1487 Eq,
1488 Hash,
1489 Ord,
1490 PartialEq,
1491 PartialOrd,
1492 )]
1493 #[serde(transparent)]
1494 pub struct Cursor(pub ::std::string::String);
1495 impl ::std::ops::Deref for Cursor {
1496 type Target = ::std::string::String;
1497 fn deref(&self) -> &::std::string::String {
1498 &self.0
1499 }
1500 }
1501
1502 impl ::std::convert::From<Cursor> for ::std::string::String {
1503 fn from(value: Cursor) -> Self {
1504 value.0
1505 }
1506 }
1507
1508 impl ::std::convert::From<::std::string::String> for Cursor {
1509 fn from(value: ::std::string::String) -> Self {
1510 Self(value)
1511 }
1512 }
1513
1514 impl ::std::str::FromStr for Cursor {
1515 type Err = ::std::convert::Infallible;
1516 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
1517 Ok(Self(value.to_string()))
1518 }
1519 }
1520
1521 impl ::std::fmt::Display for Cursor {
1522 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1523 self.0.fmt(f)
1524 }
1525 }
1526
1527 ///`DatabaseRole`
1528 ///
1529 /// <details><summary>JSON schema</summary>
1530 ///
1531 /// ```json
1532 ///{
1533 /// "type": "string"
1534 ///}
1535 /// ```
1536 /// </details>
1537 #[derive(
1538 :: serde :: Deserialize,
1539 :: serde :: Serialize,
1540 Clone,
1541 Debug,
1542 Eq,
1543 Hash,
1544 Ord,
1545 PartialEq,
1546 PartialOrd,
1547 )]
1548 #[serde(transparent)]
1549 pub struct DatabaseRole(pub ::std::string::String);
1550 impl ::std::ops::Deref for DatabaseRole {
1551 type Target = ::std::string::String;
1552 fn deref(&self) -> &::std::string::String {
1553 &self.0
1554 }
1555 }
1556
1557 impl ::std::convert::From<DatabaseRole> for ::std::string::String {
1558 fn from(value: DatabaseRole) -> Self {
1559 value.0
1560 }
1561 }
1562
1563 impl ::std::convert::From<::std::string::String> for DatabaseRole {
1564 fn from(value: ::std::string::String) -> Self {
1565 Self(value)
1566 }
1567 }
1568
1569 impl ::std::str::FromStr for DatabaseRole {
1570 type Err = ::std::convert::Infallible;
1571 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
1572 Ok(Self(value.to_string()))
1573 }
1574 }
1575
1576 impl ::std::fmt::Display for DatabaseRole {
1577 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1578 self.0.fmt(f)
1579 }
1580 }
1581
1582 ///`DatabaseStatus`
1583 ///
1584 /// <details><summary>JSON schema</summary>
1585 ///
1586 /// ```json
1587 ///{
1588 /// "type": "string"
1589 ///}
1590 /// ```
1591 /// </details>
1592 #[derive(
1593 :: serde :: Deserialize,
1594 :: serde :: Serialize,
1595 Clone,
1596 Debug,
1597 Eq,
1598 Hash,
1599 Ord,
1600 PartialEq,
1601 PartialOrd,
1602 )]
1603 #[serde(transparent)]
1604 pub struct DatabaseStatus(pub ::std::string::String);
1605 impl ::std::ops::Deref for DatabaseStatus {
1606 type Target = ::std::string::String;
1607 fn deref(&self) -> &::std::string::String {
1608 &self.0
1609 }
1610 }
1611
1612 impl ::std::convert::From<DatabaseStatus> for ::std::string::String {
1613 fn from(value: DatabaseStatus) -> Self {
1614 value.0
1615 }
1616 }
1617
1618 impl ::std::convert::From<::std::string::String> for DatabaseStatus {
1619 fn from(value: ::std::string::String) -> Self {
1620 Self(value)
1621 }
1622 }
1623
1624 impl ::std::str::FromStr for DatabaseStatus {
1625 type Err = ::std::convert::Infallible;
1626 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
1627 Ok(Self(value.to_string()))
1628 }
1629 }
1630
1631 impl ::std::fmt::Display for DatabaseStatus {
1632 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1633 self.0.fmt(f)
1634 }
1635 }
1636
1637 ///`Deploy`
1638 ///
1639 /// <details><summary>JSON schema</summary>
1640 ///
1641 /// ```json
1642 ///{
1643 /// "type": "object",
1644 /// "properties": {
1645 /// "commit": {
1646 /// "type": "object",
1647 /// "properties": {
1648 /// "createdAt": {
1649 /// "type": "string",
1650 /// "format": "date-time"
1651 /// },
1652 /// "id": {
1653 /// "type": "string"
1654 /// },
1655 /// "message": {
1656 /// "type": "string"
1657 /// }
1658 /// }
1659 /// },
1660 /// "createdAt": {
1661 /// "type": "string",
1662 /// "format": "date-time"
1663 /// },
1664 /// "finishedAt": {
1665 /// "type": "string",
1666 /// "format": "date-time"
1667 /// },
1668 /// "id": {
1669 /// "type": "string"
1670 /// },
1671 /// "image": {
1672 /// "description": "Image information used when creating the deploy.
1673 /// Not present for Git-backed deploys",
1674 /// "type": "object",
1675 /// "properties": {
1676 /// "ref": {
1677 /// "description": "Image reference used when creating the deploy",
1678 /// "type": "string"
1679 /// },
1680 /// "registryCredential": {
1681 /// "description": "Name of credential used to pull the image, if
1682 /// provided",
1683 /// "type": "string"
1684 /// },
1685 /// "sha": {
1686 /// "description": "SHA that the image reference was resolved to
1687 /// when creating the deploy",
1688 /// "type": "string"
1689 /// }
1690 /// }
1691 /// },
1692 /// "startedAt": {
1693 /// "type": "string",
1694 /// "format": "date-time"
1695 /// },
1696 /// "status": {
1697 /// "$ref": "#/components/schemas/deployStatus"
1698 /// },
1699 /// "trigger": {
1700 /// "type": "string"
1701 /// },
1702 /// "updatedAt": {
1703 /// "type": "string",
1704 /// "format": "date-time"
1705 /// }
1706 /// }
1707 ///}
1708 /// ```
1709 /// </details>
1710 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1711 pub struct Deploy {
1712 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1713 pub commit: ::std::option::Option<DeployCommit>,
1714 #[serde(
1715 rename = "createdAt",
1716 default,
1717 skip_serializing_if = "::std::option::Option::is_none"
1718 )]
1719 pub created_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
1720 #[serde(
1721 rename = "finishedAt",
1722 default,
1723 skip_serializing_if = "::std::option::Option::is_none"
1724 )]
1725 pub finished_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
1726 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1727 pub id: ::std::option::Option<::std::string::String>,
1728 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1729 pub image: ::std::option::Option<DeployImage>,
1730 #[serde(
1731 rename = "startedAt",
1732 default,
1733 skip_serializing_if = "::std::option::Option::is_none"
1734 )]
1735 pub started_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
1736 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1737 pub status: ::std::option::Option<DeployStatus>,
1738 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1739 pub trigger: ::std::option::Option<::std::string::String>,
1740 #[serde(
1741 rename = "updatedAt",
1742 default,
1743 skip_serializing_if = "::std::option::Option::is_none"
1744 )]
1745 pub updated_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
1746 }
1747
1748 impl ::std::default::Default for Deploy {
1749 fn default() -> Self {
1750 Self {
1751 commit: Default::default(),
1752 created_at: Default::default(),
1753 finished_at: Default::default(),
1754 id: Default::default(),
1755 image: Default::default(),
1756 started_at: Default::default(),
1757 status: Default::default(),
1758 trigger: Default::default(),
1759 updated_at: Default::default(),
1760 }
1761 }
1762 }
1763
1764 ///`DeployCommit`
1765 ///
1766 /// <details><summary>JSON schema</summary>
1767 ///
1768 /// ```json
1769 ///{
1770 /// "type": "object",
1771 /// "properties": {
1772 /// "createdAt": {
1773 /// "type": "string",
1774 /// "format": "date-time"
1775 /// },
1776 /// "id": {
1777 /// "type": "string"
1778 /// },
1779 /// "message": {
1780 /// "type": "string"
1781 /// }
1782 /// }
1783 ///}
1784 /// ```
1785 /// </details>
1786 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1787 pub struct DeployCommit {
1788 #[serde(
1789 rename = "createdAt",
1790 default,
1791 skip_serializing_if = "::std::option::Option::is_none"
1792 )]
1793 pub created_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
1794 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1795 pub id: ::std::option::Option<::std::string::String>,
1796 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1797 pub message: ::std::option::Option<::std::string::String>,
1798 }
1799
1800 impl ::std::default::Default for DeployCommit {
1801 fn default() -> Self {
1802 Self {
1803 created_at: Default::default(),
1804 id: Default::default(),
1805 message: Default::default(),
1806 }
1807 }
1808 }
1809
1810 ///Image information used when creating the deploy. Not present for
1811 /// Git-backed deploys
1812 ///
1813 /// <details><summary>JSON schema</summary>
1814 ///
1815 /// ```json
1816 ///{
1817 /// "description": "Image information used when creating the deploy. Not
1818 /// present for Git-backed deploys",
1819 /// "type": "object",
1820 /// "properties": {
1821 /// "ref": {
1822 /// "description": "Image reference used when creating the deploy",
1823 /// "type": "string"
1824 /// },
1825 /// "registryCredential": {
1826 /// "description": "Name of credential used to pull the image, if
1827 /// provided",
1828 /// "type": "string"
1829 /// },
1830 /// "sha": {
1831 /// "description": "SHA that the image reference was resolved to when
1832 /// creating the deploy",
1833 /// "type": "string"
1834 /// }
1835 /// }
1836 ///}
1837 /// ```
1838 /// </details>
1839 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1840 pub struct DeployImage {
1841 ///Image reference used when creating the deploy
1842 #[serde(
1843 rename = "ref",
1844 default,
1845 skip_serializing_if = "::std::option::Option::is_none"
1846 )]
1847 pub ref_: ::std::option::Option<::std::string::String>,
1848 ///Name of credential used to pull the image, if provided
1849 #[serde(
1850 rename = "registryCredential",
1851 default,
1852 skip_serializing_if = "::std::option::Option::is_none"
1853 )]
1854 pub registry_credential: ::std::option::Option<::std::string::String>,
1855 ///SHA that the image reference was resolved to when creating the
1856 /// deploy
1857 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
1858 pub sha: ::std::option::Option<::std::string::String>,
1859 }
1860
1861 impl ::std::default::Default for DeployImage {
1862 fn default() -> Self {
1863 Self {
1864 ref_: Default::default(),
1865 registry_credential: Default::default(),
1866 sha: Default::default(),
1867 }
1868 }
1869 }
1870
1871 ///`DeployList`
1872 ///
1873 /// <details><summary>JSON schema</summary>
1874 ///
1875 /// ```json
1876 ///{
1877 /// "type": "array",
1878 /// "items": {
1879 /// "$ref": "#/components/schemas/deployWithCursor"
1880 /// }
1881 ///}
1882 /// ```
1883 /// </details>
1884 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
1885 #[serde(transparent)]
1886 pub struct DeployList(pub ::std::vec::Vec<DeployWithCursor>);
1887 impl ::std::ops::Deref for DeployList {
1888 type Target = ::std::vec::Vec<DeployWithCursor>;
1889 fn deref(&self) -> &::std::vec::Vec<DeployWithCursor> {
1890 &self.0
1891 }
1892 }
1893
1894 impl ::std::convert::From<DeployList> for ::std::vec::Vec<DeployWithCursor> {
1895 fn from(value: DeployList) -> Self {
1896 value.0
1897 }
1898 }
1899
1900 impl ::std::convert::From<::std::vec::Vec<DeployWithCursor>> for DeployList {
1901 fn from(value: ::std::vec::Vec<DeployWithCursor>) -> Self {
1902 Self(value)
1903 }
1904 }
1905
1906 ///Controls deployment behavior when triggering a deploy.
1907 ///
1908 /// - `deploy_only`: Deploy the last successful build without rebuilding
1909 /// (minimizes downtime)
1910 /// - `build_and_deploy`: Build new code and deploy it (default behavior
1911 /// when not specified)
1912 ///
1913 ///**Note:** `deploy_only` cannot be combined with `commitId`, `imageUrl`
1914 /// or `clearCache` parameters, as those are build related fields.
1915 ///
1916 /// <details><summary>JSON schema</summary>
1917 ///
1918 /// ```json
1919 ///{
1920 /// "description": "Controls deployment behavior when triggering a
1921 /// deploy.\n\n- `deploy_only`: Deploy the last successful build without
1922 /// rebuilding (minimizes downtime)\n- `build_and_deploy`: Build new code
1923 /// and deploy it (default behavior when not specified)\n\n**Note:**
1924 /// `deploy_only` cannot be combined with `commitId`, `imageUrl` or
1925 /// `clearCache` parameters,\nas those are build related fields.\n",
1926 /// "default": "build_and_deploy",
1927 /// "type": "string"
1928 ///}
1929 /// ```
1930 /// </details>
1931 #[derive(
1932 :: serde :: Deserialize,
1933 :: serde :: Serialize,
1934 Clone,
1935 Debug,
1936 Eq,
1937 Hash,
1938 Ord,
1939 PartialEq,
1940 PartialOrd,
1941 )]
1942 #[serde(transparent)]
1943 pub struct DeployMode(pub ::std::string::String);
1944 impl ::std::ops::Deref for DeployMode {
1945 type Target = ::std::string::String;
1946 fn deref(&self) -> &::std::string::String {
1947 &self.0
1948 }
1949 }
1950
1951 impl ::std::convert::From<DeployMode> for ::std::string::String {
1952 fn from(value: DeployMode) -> Self {
1953 value.0
1954 }
1955 }
1956
1957 impl ::std::convert::From<::std::string::String> for DeployMode {
1958 fn from(value: ::std::string::String) -> Self {
1959 Self(value)
1960 }
1961 }
1962
1963 impl ::std::str::FromStr for DeployMode {
1964 type Err = ::std::convert::Infallible;
1965 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
1966 Ok(Self(value.to_string()))
1967 }
1968 }
1969
1970 impl ::std::fmt::Display for DeployMode {
1971 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1972 self.0.fmt(f)
1973 }
1974 }
1975
1976 ///`DeployStatus`
1977 ///
1978 /// <details><summary>JSON schema</summary>
1979 ///
1980 /// ```json
1981 ///{
1982 /// "type": "string"
1983 ///}
1984 /// ```
1985 /// </details>
1986 #[derive(
1987 :: serde :: Deserialize,
1988 :: serde :: Serialize,
1989 Clone,
1990 Debug,
1991 Eq,
1992 Hash,
1993 Ord,
1994 PartialEq,
1995 PartialOrd,
1996 )]
1997 #[serde(transparent)]
1998 pub struct DeployStatus(pub ::std::string::String);
1999 impl ::std::ops::Deref for DeployStatus {
2000 type Target = ::std::string::String;
2001 fn deref(&self) -> &::std::string::String {
2002 &self.0
2003 }
2004 }
2005
2006 impl ::std::convert::From<DeployStatus> for ::std::string::String {
2007 fn from(value: DeployStatus) -> Self {
2008 value.0
2009 }
2010 }
2011
2012 impl ::std::convert::From<::std::string::String> for DeployStatus {
2013 fn from(value: ::std::string::String) -> Self {
2014 Self(value)
2015 }
2016 }
2017
2018 impl ::std::str::FromStr for DeployStatus {
2019 type Err = ::std::convert::Infallible;
2020 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
2021 Ok(Self(value.to_string()))
2022 }
2023 }
2024
2025 impl ::std::fmt::Display for DeployStatus {
2026 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2027 self.0.fmt(f)
2028 }
2029 }
2030
2031 ///`DeployWithCursor`
2032 ///
2033 /// <details><summary>JSON schema</summary>
2034 ///
2035 /// ```json
2036 ///{
2037 /// "type": "object",
2038 /// "properties": {
2039 /// "cursor": {
2040 /// "$ref": "#/components/schemas/cursor"
2041 /// },
2042 /// "deploy": {
2043 /// "$ref": "#/components/schemas/deploy"
2044 /// }
2045 /// }
2046 ///}
2047 /// ```
2048 /// </details>
2049 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2050 pub struct DeployWithCursor {
2051 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2052 pub cursor: ::std::option::Option<Cursor>,
2053 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2054 pub deploy: ::std::option::Option<Deploy>,
2055 }
2056
2057 impl ::std::default::Default for DeployWithCursor {
2058 fn default() -> Self {
2059 Self {
2060 cursor: Default::default(),
2061 deploy: Default::default(),
2062 }
2063 }
2064 }
2065
2066 ///`DockerDetails`
2067 ///
2068 /// <details><summary>JSON schema</summary>
2069 ///
2070 /// ```json
2071 ///{
2072 /// "type": "object",
2073 /// "properties": {
2074 /// "dockerCommand": {
2075 /// "type": "string"
2076 /// },
2077 /// "dockerContext": {
2078 /// "type": "string"
2079 /// },
2080 /// "dockerfilePath": {
2081 /// "type": "string"
2082 /// },
2083 /// "preDeployCommand": {
2084 /// "type": "string"
2085 /// },
2086 /// "registryCredential": {
2087 /// "$ref": "#/components/schemas/registryCredential"
2088 /// }
2089 /// }
2090 ///}
2091 /// ```
2092 /// </details>
2093 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2094 pub struct DockerDetails {
2095 #[serde(
2096 rename = "dockerCommand",
2097 default,
2098 skip_serializing_if = "::std::option::Option::is_none"
2099 )]
2100 pub docker_command: ::std::option::Option<::std::string::String>,
2101 #[serde(
2102 rename = "dockerContext",
2103 default,
2104 skip_serializing_if = "::std::option::Option::is_none"
2105 )]
2106 pub docker_context: ::std::option::Option<::std::string::String>,
2107 #[serde(
2108 rename = "dockerfilePath",
2109 default,
2110 skip_serializing_if = "::std::option::Option::is_none"
2111 )]
2112 pub dockerfile_path: ::std::option::Option<::std::string::String>,
2113 #[serde(
2114 rename = "preDeployCommand",
2115 default,
2116 skip_serializing_if = "::std::option::Option::is_none"
2117 )]
2118 pub pre_deploy_command: ::std::option::Option<::std::string::String>,
2119 #[serde(
2120 rename = "registryCredential",
2121 default,
2122 skip_serializing_if = "::std::option::Option::is_none"
2123 )]
2124 pub registry_credential: ::std::option::Option<RegistryCredential>,
2125 }
2126
2127 impl ::std::default::Default for DockerDetails {
2128 fn default() -> Self {
2129 Self {
2130 docker_command: Default::default(),
2131 docker_context: Default::default(),
2132 dockerfile_path: Default::default(),
2133 pre_deploy_command: Default::default(),
2134 registry_credential: Default::default(),
2135 }
2136 }
2137 }
2138
2139 ///`DockerDetailsPost`
2140 ///
2141 /// <details><summary>JSON schema</summary>
2142 ///
2143 /// ```json
2144 ///{
2145 /// "type": "object",
2146 /// "properties": {
2147 /// "dockerCommand": {
2148 /// "type": "string"
2149 /// },
2150 /// "dockerContext": {
2151 /// "type": "string"
2152 /// },
2153 /// "dockerfilePath": {
2154 /// "description": "Defaults to \"./Dockerfile\"",
2155 /// "type": "string"
2156 /// },
2157 /// "registryCredentialId": {
2158 /// "type": "string"
2159 /// }
2160 /// }
2161 ///}
2162 /// ```
2163 /// </details>
2164 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2165 pub struct DockerDetailsPost {
2166 #[serde(
2167 rename = "dockerCommand",
2168 default,
2169 skip_serializing_if = "::std::option::Option::is_none"
2170 )]
2171 pub docker_command: ::std::option::Option<::std::string::String>,
2172 #[serde(
2173 rename = "dockerContext",
2174 default,
2175 skip_serializing_if = "::std::option::Option::is_none"
2176 )]
2177 pub docker_context: ::std::option::Option<::std::string::String>,
2178 ///Defaults to "./Dockerfile"
2179 #[serde(
2180 rename = "dockerfilePath",
2181 default,
2182 skip_serializing_if = "::std::option::Option::is_none"
2183 )]
2184 pub dockerfile_path: ::std::option::Option<::std::string::String>,
2185 #[serde(
2186 rename = "registryCredentialId",
2187 default,
2188 skip_serializing_if = "::std::option::Option::is_none"
2189 )]
2190 pub registry_credential_id: ::std::option::Option<::std::string::String>,
2191 }
2192
2193 impl ::std::default::Default for DockerDetailsPost {
2194 fn default() -> Self {
2195 Self {
2196 docker_command: Default::default(),
2197 docker_context: Default::default(),
2198 dockerfile_path: Default::default(),
2199 registry_credential_id: Default::default(),
2200 }
2201 }
2202 }
2203
2204 ///`EnvSpecificDetails`
2205 ///
2206 /// <details><summary>JSON schema</summary>
2207 ///
2208 /// ```json
2209 ///{
2210 /// "oneOf": [
2211 /// {
2212 /// "$ref": "#/components/schemas/dockerDetails"
2213 /// },
2214 /// {
2215 /// "$ref": "#/components/schemas/nativeEnvironmentDetails"
2216 /// }
2217 /// ]
2218 ///}
2219 /// ```
2220 /// </details>
2221 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2222 #[serde(untagged)]
2223 pub enum EnvSpecificDetails {
2224 DockerDetails(DockerDetails),
2225 NativeEnvironmentDetails(NativeEnvironmentDetails),
2226 }
2227
2228 impl ::std::convert::From<DockerDetails> for EnvSpecificDetails {
2229 fn from(value: DockerDetails) -> Self {
2230 Self::DockerDetails(value)
2231 }
2232 }
2233
2234 impl ::std::convert::From<NativeEnvironmentDetails> for EnvSpecificDetails {
2235 fn from(value: NativeEnvironmentDetails) -> Self {
2236 Self::NativeEnvironmentDetails(value)
2237 }
2238 }
2239
2240 ///`EnvSpecificDetailsPost`
2241 ///
2242 /// <details><summary>JSON schema</summary>
2243 ///
2244 /// ```json
2245 ///{
2246 /// "oneOf": [
2247 /// {
2248 /// "$ref": "#/components/schemas/dockerDetailsPOST"
2249 /// },
2250 /// {
2251 /// "$ref": "#/components/schemas/nativeEnvironmentDetailsPOST"
2252 /// }
2253 /// ]
2254 ///}
2255 /// ```
2256 /// </details>
2257 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2258 #[serde(untagged)]
2259 pub enum EnvSpecificDetailsPost {
2260 DockerDetailsPost(DockerDetailsPost),
2261 NativeEnvironmentDetailsPost(NativeEnvironmentDetailsPost),
2262 }
2263
2264 impl ::std::convert::From<DockerDetailsPost> for EnvSpecificDetailsPost {
2265 fn from(value: DockerDetailsPost) -> Self {
2266 Self::DockerDetailsPost(value)
2267 }
2268 }
2269
2270 impl ::std::convert::From<NativeEnvironmentDetailsPost> for EnvSpecificDetailsPost {
2271 fn from(value: NativeEnvironmentDetailsPost) -> Self {
2272 Self::NativeEnvironmentDetailsPost(value)
2273 }
2274 }
2275
2276 ///`EnvVar`
2277 ///
2278 /// <details><summary>JSON schema</summary>
2279 ///
2280 /// ```json
2281 ///{
2282 /// "type": "object",
2283 /// "properties": {
2284 /// "key": {
2285 /// "type": "string"
2286 /// },
2287 /// "value": {
2288 /// "type": "string"
2289 /// }
2290 /// }
2291 ///}
2292 /// ```
2293 /// </details>
2294 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2295 pub struct EnvVar {
2296 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2297 pub key: ::std::option::Option<::std::string::String>,
2298 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2299 pub value: ::std::option::Option<::std::string::String>,
2300 }
2301
2302 impl ::std::default::Default for EnvVar {
2303 fn default() -> Self {
2304 Self {
2305 key: Default::default(),
2306 value: Default::default(),
2307 }
2308 }
2309 }
2310
2311 ///`EnvVarWithCursor`
2312 ///
2313 /// <details><summary>JSON schema</summary>
2314 ///
2315 /// ```json
2316 ///{
2317 /// "type": "object",
2318 /// "properties": {
2319 /// "cursor": {
2320 /// "$ref": "#/components/schemas/cursor"
2321 /// },
2322 /// "envVar": {
2323 /// "$ref": "#/components/schemas/envVar"
2324 /// }
2325 /// }
2326 ///}
2327 /// ```
2328 /// </details>
2329 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2330 pub struct EnvVarWithCursor {
2331 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2332 pub cursor: ::std::option::Option<Cursor>,
2333 #[serde(
2334 rename = "envVar",
2335 default,
2336 skip_serializing_if = "::std::option::Option::is_none"
2337 )]
2338 pub env_var: ::std::option::Option<EnvVar>,
2339 }
2340
2341 impl ::std::default::Default for EnvVarWithCursor {
2342 fn default() -> Self {
2343 Self {
2344 cursor: Default::default(),
2345 env_var: Default::default(),
2346 }
2347 }
2348 }
2349
2350 ///`Error`
2351 ///
2352 /// <details><summary>JSON schema</summary>
2353 ///
2354 /// ```json
2355 ///{
2356 /// "type": "object",
2357 /// "properties": {
2358 /// "id": {
2359 /// "type": "string"
2360 /// },
2361 /// "message": {
2362 /// "type": "string"
2363 /// }
2364 /// }
2365 ///}
2366 /// ```
2367 /// </details>
2368 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2369 pub struct Error {
2370 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2371 pub id: ::std::option::Option<::std::string::String>,
2372 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2373 pub message: ::std::option::Option<::std::string::String>,
2374 }
2375
2376 impl ::std::default::Default for Error {
2377 fn default() -> Self {
2378 Self {
2379 id: Default::default(),
2380 message: Default::default(),
2381 }
2382 }
2383 }
2384
2385 ///`HeaderInput`
2386 ///
2387 /// <details><summary>JSON schema</summary>
2388 ///
2389 /// ```json
2390 ///{
2391 /// "type": "object",
2392 /// "properties": {
2393 /// "name": {
2394 /// "description": "Header name",
2395 /// "examples": [
2396 /// "Cache-Control"
2397 /// ],
2398 /// "type": "string"
2399 /// },
2400 /// "path": {
2401 /// "description": "The request path to add the header to. Wildcards
2402 /// will cause headers to be applied to all matching paths.",
2403 /// "examples": [
2404 /// "/static/*"
2405 /// ],
2406 /// "type": "string"
2407 /// },
2408 /// "value": {
2409 /// "description": "Header value",
2410 /// "examples": [
2411 /// "public, max-age=604800"
2412 /// ],
2413 /// "type": "string"
2414 /// }
2415 /// }
2416 ///}
2417 /// ```
2418 /// </details>
2419 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2420 pub struct HeaderInput {
2421 ///Header name
2422 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2423 pub name: ::std::option::Option<::std::string::String>,
2424 ///The request path to add the header to. Wildcards will cause headers
2425 /// to be applied to all matching paths.
2426 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2427 pub path: ::std::option::Option<::std::string::String>,
2428 ///Header value
2429 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2430 pub value: ::std::option::Option<::std::string::String>,
2431 }
2432
2433 impl ::std::default::Default for HeaderInput {
2434 fn default() -> Self {
2435 Self {
2436 name: Default::default(),
2437 path: Default::default(),
2438 value: Default::default(),
2439 }
2440 }
2441 }
2442
2443 ///`Image`
2444 ///
2445 /// <details><summary>JSON schema</summary>
2446 ///
2447 /// ```json
2448 ///{
2449 /// "type": "object",
2450 /// "properties": {
2451 /// "imagePath": {
2452 /// "description": "Path to the image used for this server (e.g
2453 /// docker.io/library/nginx:latest).",
2454 /// "type": "string"
2455 /// },
2456 /// "ownerId": {
2457 /// "description": "The ID of the owner for this image. This should
2458 /// match the owner of the service as well as the owner of any specified
2459 /// registry credential.",
2460 /// "type": "string"
2461 /// },
2462 /// "registryCredentialId": {
2463 /// "description": "Optional reference to the registry credential
2464 /// passed to the image repository to retrieve this image.",
2465 /// "type": "string"
2466 /// }
2467 /// }
2468 ///}
2469 /// ```
2470 /// </details>
2471 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2472 pub struct Image {
2473 ///Path to the image used for this server (e.g
2474 /// docker.io/library/nginx:latest).
2475 #[serde(
2476 rename = "imagePath",
2477 default,
2478 skip_serializing_if = "::std::option::Option::is_none"
2479 )]
2480 pub image_path: ::std::option::Option<::std::string::String>,
2481 ///The ID of the owner for this image. This should match the owner of
2482 /// the service as well as the owner of any specified registry
2483 /// credential.
2484 #[serde(
2485 rename = "ownerId",
2486 default,
2487 skip_serializing_if = "::std::option::Option::is_none"
2488 )]
2489 pub owner_id: ::std::option::Option<::std::string::String>,
2490 ///Optional reference to the registry credential passed to the image
2491 /// repository to retrieve this image.
2492 #[serde(
2493 rename = "registryCredentialId",
2494 default,
2495 skip_serializing_if = "::std::option::Option::is_none"
2496 )]
2497 pub registry_credential_id: ::std::option::Option<::std::string::String>,
2498 }
2499
2500 impl ::std::default::Default for Image {
2501 fn default() -> Self {
2502 Self {
2503 image_path: Default::default(),
2504 owner_id: Default::default(),
2505 registry_credential_id: Default::default(),
2506 }
2507 }
2508 }
2509
2510 ///A run of a cron job
2511 ///
2512 /// <details><summary>JSON schema</summary>
2513 ///
2514 /// ```json
2515 ///{
2516 /// "description": "A run of a cron job",
2517 /// "type": "object",
2518 /// "properties": {
2519 /// "hasMore": {
2520 /// "description": "True if there are more logs to fetch",
2521 /// "type": "boolean"
2522 /// },
2523 /// "logs": {
2524 /// "type": "array",
2525 /// "items": {
2526 /// "description": "A log entry with metadata",
2527 /// "type": "object",
2528 /// "properties": {
2529 /// "id": {
2530 /// "description": "A unique ID of the log entry",
2531 /// "type": "string"
2532 /// },
2533 /// "labels": {
2534 /// "type": "array",
2535 /// "items": {
2536 /// "description": "A log label",
2537 /// "type": "object",
2538 /// "properties": {
2539 /// "name": {
2540 /// "description": "The name of the log label",
2541 /// "type": "string"
2542 /// },
2543 /// "value": {
2544 /// "description": "The value of the log label",
2545 /// "type": "string"
2546 /// }
2547 /// }
2548 /// }
2549 /// },
2550 /// "message": {
2551 /// "description": "The message of the log entry",
2552 /// "type": "string"
2553 /// },
2554 /// "timestamp": {
2555 /// "description": "The timestamp of the log entry",
2556 /// "type": "string",
2557 /// "format": "date-time"
2558 /// }
2559 /// }
2560 /// }
2561 /// },
2562 /// "nextEndTime": {
2563 /// "description": "The end time to use in the next query to fetch the
2564 /// next set of logs",
2565 /// "examples": [
2566 /// "2021-07-15T07:20:05.777035-07:00"
2567 /// ],
2568 /// "type": "string",
2569 /// "format": "date-time"
2570 /// },
2571 /// "nextStartTime": {
2572 /// "description": "The start time to use in the next query to fetch
2573 /// the next set of logs",
2574 /// "examples": [
2575 /// "2021-07-15T07:20:05.777035-07:00"
2576 /// ],
2577 /// "type": "string",
2578 /// "format": "date-time"
2579 /// }
2580 /// }
2581 ///}
2582 /// ```
2583 /// </details>
2584 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2585 pub struct ListLogsResponse {
2586 ///True if there are more logs to fetch
2587 #[serde(
2588 rename = "hasMore",
2589 default,
2590 skip_serializing_if = "::std::option::Option::is_none"
2591 )]
2592 pub has_more: ::std::option::Option<bool>,
2593 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2594 pub logs: ::std::option::Option<::std::vec::Vec<ListLogsResponseLogsItem>>,
2595 ///The end time to use in the next query to fetch the next set of logs
2596 #[serde(
2597 rename = "nextEndTime",
2598 default,
2599 skip_serializing_if = "::std::option::Option::is_none"
2600 )]
2601 pub next_end_time: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
2602 ///The start time to use in the next query to fetch the next set of
2603 /// logs
2604 #[serde(
2605 rename = "nextStartTime",
2606 default,
2607 skip_serializing_if = "::std::option::Option::is_none"
2608 )]
2609 pub next_start_time: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
2610 }
2611
2612 impl ::std::default::Default for ListLogsResponse {
2613 fn default() -> Self {
2614 Self {
2615 has_more: Default::default(),
2616 logs: Default::default(),
2617 next_end_time: Default::default(),
2618 next_start_time: Default::default(),
2619 }
2620 }
2621 }
2622
2623 ///A log entry with metadata
2624 ///
2625 /// <details><summary>JSON schema</summary>
2626 ///
2627 /// ```json
2628 ///{
2629 /// "description": "A log entry with metadata",
2630 /// "type": "object",
2631 /// "properties": {
2632 /// "id": {
2633 /// "description": "A unique ID of the log entry",
2634 /// "type": "string"
2635 /// },
2636 /// "labels": {
2637 /// "type": "array",
2638 /// "items": {
2639 /// "description": "A log label",
2640 /// "type": "object",
2641 /// "properties": {
2642 /// "name": {
2643 /// "description": "The name of the log label",
2644 /// "type": "string"
2645 /// },
2646 /// "value": {
2647 /// "description": "The value of the log label",
2648 /// "type": "string"
2649 /// }
2650 /// }
2651 /// }
2652 /// },
2653 /// "message": {
2654 /// "description": "The message of the log entry",
2655 /// "type": "string"
2656 /// },
2657 /// "timestamp": {
2658 /// "description": "The timestamp of the log entry",
2659 /// "type": "string",
2660 /// "format": "date-time"
2661 /// }
2662 /// }
2663 ///}
2664 /// ```
2665 /// </details>
2666 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2667 pub struct ListLogsResponseLogsItem {
2668 ///A unique ID of the log entry
2669 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2670 pub id: ::std::option::Option<::std::string::String>,
2671 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
2672 pub labels: ::std::vec::Vec<ListLogsResponseLogsItemLabelsItem>,
2673 ///The message of the log entry
2674 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2675 pub message: ::std::option::Option<::std::string::String>,
2676 ///The timestamp of the log entry
2677 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2678 pub timestamp: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
2679 }
2680
2681 impl ::std::default::Default for ListLogsResponseLogsItem {
2682 fn default() -> Self {
2683 Self {
2684 id: Default::default(),
2685 labels: Default::default(),
2686 message: Default::default(),
2687 timestamp: Default::default(),
2688 }
2689 }
2690 }
2691
2692 ///A log label
2693 ///
2694 /// <details><summary>JSON schema</summary>
2695 ///
2696 /// ```json
2697 ///{
2698 /// "description": "A log label",
2699 /// "type": "object",
2700 /// "properties": {
2701 /// "name": {
2702 /// "description": "The name of the log label",
2703 /// "type": "string"
2704 /// },
2705 /// "value": {
2706 /// "description": "The value of the log label",
2707 /// "type": "string"
2708 /// }
2709 /// }
2710 ///}
2711 /// ```
2712 /// </details>
2713 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2714 pub struct ListLogsResponseLogsItemLabelsItem {
2715 ///The name of the log label
2716 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2717 pub name: ::std::option::Option<::std::string::String>,
2718 ///The value of the log label
2719 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2720 pub value: ::std::option::Option<::std::string::String>,
2721 }
2722
2723 impl ::std::default::Default for ListLogsResponseLogsItemLabelsItem {
2724 fn default() -> Self {
2725 Self {
2726 name: Default::default(),
2727 value: Default::default(),
2728 }
2729 }
2730 }
2731
2732 ///`MaintenanceMode`
2733 ///
2734 /// <details><summary>JSON schema</summary>
2735 ///
2736 /// ```json
2737 ///{
2738 /// "type": "object",
2739 /// "properties": {
2740 /// "enabled": {
2741 /// "type": "boolean"
2742 /// },
2743 /// "uri": {
2744 /// "description": "The page to be served when [maintenance mode](https://render.com/docs/maintenance-mode) is enabled. When empty, the default maintenance mode page is served.",
2745 /// "type": "string"
2746 /// }
2747 /// }
2748 ///}
2749 /// ```
2750 /// </details>
2751 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2752 pub struct MaintenanceMode {
2753 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2754 pub enabled: ::std::option::Option<bool>,
2755 ///The page to be served when [maintenance mode](https://render.com/docs/maintenance-mode) is enabled. When empty, the default maintenance mode page is served.
2756 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
2757 pub uri: ::std::option::Option<::std::string::String>,
2758 }
2759
2760 impl ::std::default::Default for MaintenanceMode {
2761 fn default() -> Self {
2762 Self {
2763 enabled: Default::default(),
2764 uri: Default::default(),
2765 }
2766 }
2767 }
2768
2769 ///The maximum amount of time (in seconds) that Render waits for your
2770 /// application process to exit gracefully after sending it a SIGTERM
2771 /// signal.
2772 ///
2773 /// <details><summary>JSON schema</summary>
2774 ///
2775 /// ```json
2776 ///{
2777 /// "description": "The maximum amount of time (in seconds) that Render
2778 /// waits for your application process to exit gracefully after sending it a
2779 /// SIGTERM signal.",
2780 /// "default": 30,
2781 /// "type": "integer",
2782 /// "maximum": 300.0,
2783 /// "minimum": 1.0
2784 ///}
2785 /// ```
2786 /// </details>
2787 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2788 #[serde(transparent)]
2789 pub struct MaxShutdownDelaySeconds(pub ::std::num::NonZeroU64);
2790 impl ::std::ops::Deref for MaxShutdownDelaySeconds {
2791 type Target = ::std::num::NonZeroU64;
2792 fn deref(&self) -> &::std::num::NonZeroU64 {
2793 &self.0
2794 }
2795 }
2796
2797 impl ::std::convert::From<MaxShutdownDelaySeconds> for ::std::num::NonZeroU64 {
2798 fn from(value: MaxShutdownDelaySeconds) -> Self {
2799 value.0
2800 }
2801 }
2802
2803 impl ::std::convert::From<::std::num::NonZeroU64> for MaxShutdownDelaySeconds {
2804 fn from(value: ::std::num::NonZeroU64) -> Self {
2805 Self(value)
2806 }
2807 }
2808
2809 impl ::std::str::FromStr for MaxShutdownDelaySeconds {
2810 type Err = <::std::num::NonZeroU64 as ::std::str::FromStr>::Err;
2811 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
2812 Ok(Self(value.parse()?))
2813 }
2814 }
2815
2816 impl ::std::convert::TryFrom<&str> for MaxShutdownDelaySeconds {
2817 type Error = <::std::num::NonZeroU64 as ::std::str::FromStr>::Err;
2818 fn try_from(value: &str) -> ::std::result::Result<Self, Self::Error> {
2819 value.parse()
2820 }
2821 }
2822
2823 impl ::std::convert::TryFrom<String> for MaxShutdownDelaySeconds {
2824 type Error = <::std::num::NonZeroU64 as ::std::str::FromStr>::Err;
2825 fn try_from(value: String) -> ::std::result::Result<Self, Self::Error> {
2826 value.parse()
2827 }
2828 }
2829
2830 impl ::std::fmt::Display for MaxShutdownDelaySeconds {
2831 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2832 self.0.fmt(f)
2833 }
2834 }
2835
2836 ///`NativeEnvironmentDetails`
2837 ///
2838 /// <details><summary>JSON schema</summary>
2839 ///
2840 /// ```json
2841 ///{
2842 /// "type": "object",
2843 /// "properties": {
2844 /// "buildCommand": {
2845 /// "type": "string"
2846 /// },
2847 /// "preDeployCommand": {
2848 /// "type": "string"
2849 /// },
2850 /// "startCommand": {
2851 /// "type": "string"
2852 /// }
2853 /// }
2854 ///}
2855 /// ```
2856 /// </details>
2857 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2858 pub struct NativeEnvironmentDetails {
2859 #[serde(
2860 rename = "buildCommand",
2861 default,
2862 skip_serializing_if = "::std::option::Option::is_none"
2863 )]
2864 pub build_command: ::std::option::Option<::std::string::String>,
2865 #[serde(
2866 rename = "preDeployCommand",
2867 default,
2868 skip_serializing_if = "::std::option::Option::is_none"
2869 )]
2870 pub pre_deploy_command: ::std::option::Option<::std::string::String>,
2871 #[serde(
2872 rename = "startCommand",
2873 default,
2874 skip_serializing_if = "::std::option::Option::is_none"
2875 )]
2876 pub start_command: ::std::option::Option<::std::string::String>,
2877 }
2878
2879 impl ::std::default::Default for NativeEnvironmentDetails {
2880 fn default() -> Self {
2881 Self {
2882 build_command: Default::default(),
2883 pre_deploy_command: Default::default(),
2884 start_command: Default::default(),
2885 }
2886 }
2887 }
2888
2889 ///Fields for native environment (runtime) services
2890 ///
2891 /// <details><summary>JSON schema</summary>
2892 ///
2893 /// ```json
2894 ///{
2895 /// "description": "Fields for native environment (runtime) services",
2896 /// "type": "object",
2897 /// "properties": {
2898 /// "buildCommand": {
2899 /// "type": "string"
2900 /// },
2901 /// "startCommand": {
2902 /// "type": "string"
2903 /// }
2904 /// }
2905 ///}
2906 /// ```
2907 /// </details>
2908 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
2909 pub struct NativeEnvironmentDetailsPost {
2910 #[serde(
2911 rename = "buildCommand",
2912 default,
2913 skip_serializing_if = "::std::option::Option::is_none"
2914 )]
2915 pub build_command: ::std::option::Option<::std::string::String>,
2916 #[serde(
2917 rename = "startCommand",
2918 default,
2919 skip_serializing_if = "::std::option::Option::is_none"
2920 )]
2921 pub start_command: ::std::option::Option<::std::string::String>,
2922 }
2923
2924 impl ::std::default::Default for NativeEnvironmentDetailsPost {
2925 fn default() -> Self {
2926 Self {
2927 build_command: Default::default(),
2928 start_command: Default::default(),
2929 }
2930 }
2931 }
2932
2933 ///`NotifySetting`
2934 ///
2935 /// <details><summary>JSON schema</summary>
2936 ///
2937 /// ```json
2938 ///{
2939 /// "type": "string"
2940 ///}
2941 /// ```
2942 /// </details>
2943 #[derive(
2944 :: serde :: Deserialize,
2945 :: serde :: Serialize,
2946 Clone,
2947 Debug,
2948 Eq,
2949 Hash,
2950 Ord,
2951 PartialEq,
2952 PartialOrd,
2953 )]
2954 #[serde(transparent)]
2955 pub struct NotifySetting(pub ::std::string::String);
2956 impl ::std::ops::Deref for NotifySetting {
2957 type Target = ::std::string::String;
2958 fn deref(&self) -> &::std::string::String {
2959 &self.0
2960 }
2961 }
2962
2963 impl ::std::convert::From<NotifySetting> for ::std::string::String {
2964 fn from(value: NotifySetting) -> Self {
2965 value.0
2966 }
2967 }
2968
2969 impl ::std::convert::From<::std::string::String> for NotifySetting {
2970 fn from(value: ::std::string::String) -> Self {
2971 Self(value)
2972 }
2973 }
2974
2975 impl ::std::str::FromStr for NotifySetting {
2976 type Err = ::std::convert::Infallible;
2977 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
2978 Ok(Self(value.to_string()))
2979 }
2980 }
2981
2982 impl ::std::fmt::Display for NotifySetting {
2983 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2984 self.0.fmt(f)
2985 }
2986 }
2987
2988 ///`Owner`
2989 ///
2990 /// <details><summary>JSON schema</summary>
2991 ///
2992 /// ```json
2993 ///{
2994 /// "type": "object",
2995 /// "properties": {
2996 /// "email": {
2997 /// "type": "string"
2998 /// },
2999 /// "id": {
3000 /// "type": "string"
3001 /// },
3002 /// "ipAllowList": {
3003 /// "type": "array",
3004 /// "items": {
3005 /// "$ref": "#/components/schemas/cidrBlockAndDescription"
3006 /// }
3007 /// },
3008 /// "name": {
3009 /// "type": "string"
3010 /// },
3011 /// "twoFactorAuthEnabled": {
3012 /// "description": "Whether two-factor authentication is enabled for
3013 /// the owner. Only present if `type` is `user`.",
3014 /// "type": "boolean"
3015 /// },
3016 /// "type": {
3017 /// "type": "string"
3018 /// }
3019 /// }
3020 ///}
3021 /// ```
3022 /// </details>
3023 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3024 pub struct Owner {
3025 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3026 pub email: ::std::option::Option<::std::string::String>,
3027 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3028 pub id: ::std::option::Option<::std::string::String>,
3029 #[serde(
3030 rename = "ipAllowList",
3031 default,
3032 skip_serializing_if = "::std::vec::Vec::is_empty"
3033 )]
3034 pub ip_allow_list: ::std::vec::Vec<CidrBlockAndDescription>,
3035 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3036 pub name: ::std::option::Option<::std::string::String>,
3037 ///Whether two-factor authentication is enabled for the owner. Only
3038 /// present if `type` is `user`.
3039 #[serde(
3040 rename = "twoFactorAuthEnabled",
3041 default,
3042 skip_serializing_if = "::std::option::Option::is_none"
3043 )]
3044 pub two_factor_auth_enabled: ::std::option::Option<bool>,
3045 #[serde(
3046 rename = "type",
3047 default,
3048 skip_serializing_if = "::std::option::Option::is_none"
3049 )]
3050 pub type_: ::std::option::Option<::std::string::String>,
3051 }
3052
3053 impl ::std::default::Default for Owner {
3054 fn default() -> Self {
3055 Self {
3056 email: Default::default(),
3057 id: Default::default(),
3058 ip_allow_list: Default::default(),
3059 name: Default::default(),
3060 two_factor_auth_enabled: Default::default(),
3061 type_: Default::default(),
3062 }
3063 }
3064 }
3065
3066 ///Defaults to `starter` when creating a new database.
3067 ///
3068 /// <details><summary>JSON schema</summary>
3069 ///
3070 /// ```json
3071 ///{
3072 /// "description": "Defaults to `starter` when creating a new database.",
3073 /// "default": "starter",
3074 /// "type": "string"
3075 ///}
3076 /// ```
3077 /// </details>
3078 #[derive(
3079 :: serde :: Deserialize,
3080 :: serde :: Serialize,
3081 Clone,
3082 Debug,
3083 Eq,
3084 Hash,
3085 Ord,
3086 PartialEq,
3087 PartialOrd,
3088 )]
3089 #[serde(transparent)]
3090 pub struct PaidPlan(pub ::std::string::String);
3091 impl ::std::ops::Deref for PaidPlan {
3092 type Target = ::std::string::String;
3093 fn deref(&self) -> &::std::string::String {
3094 &self.0
3095 }
3096 }
3097
3098 impl ::std::convert::From<PaidPlan> for ::std::string::String {
3099 fn from(value: PaidPlan) -> Self {
3100 value.0
3101 }
3102 }
3103
3104 impl ::std::convert::From<::std::string::String> for PaidPlan {
3105 fn from(value: ::std::string::String) -> Self {
3106 Self(value)
3107 }
3108 }
3109
3110 impl ::std::str::FromStr for PaidPlan {
3111 type Err = ::std::convert::Infallible;
3112 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
3113 Ok(Self(value.to_string()))
3114 }
3115 }
3116
3117 impl ::std::fmt::Display for PaidPlan {
3118 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3119 self.0.fmt(f)
3120 }
3121 }
3122
3123 ///`PatchRouteResponse`
3124 ///
3125 /// <details><summary>JSON schema</summary>
3126 ///
3127 /// ```json
3128 ///{
3129 /// "type": "object",
3130 /// "properties": {
3131 /// "headers": {
3132 /// "$ref": "#/components/schemas/route"
3133 /// }
3134 /// }
3135 ///}
3136 /// ```
3137 /// </details>
3138 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3139 pub struct PatchRouteResponse {
3140 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3141 pub headers: ::std::option::Option<Route>,
3142 }
3143
3144 impl ::std::default::Default for PatchRouteResponse {
3145 fn default() -> Self {
3146 Self {
3147 headers: Default::default(),
3148 }
3149 }
3150 }
3151
3152 ///The instance type to use. Legacy variants (`*_legacy`) identify
3153 /// grandfathered plans no longer offered for new services. Note that base
3154 /// services on any paid instance type can't create preview instances with
3155 /// the `free` instance type.
3156 ///
3157 /// <details><summary>JSON schema</summary>
3158 ///
3159 /// ```json
3160 ///{
3161 /// "description": "The instance type to use. Legacy variants (`*_legacy`)
3162 /// identify grandfathered plans no longer offered for new services. Note
3163 /// that base services on any paid instance type can't create preview
3164 /// instances with the `free` instance type.",
3165 /// "examples": [
3166 /// "starter"
3167 /// ],
3168 /// "type": "string"
3169 ///}
3170 /// ```
3171 /// </details>
3172 #[derive(
3173 :: serde :: Deserialize,
3174 :: serde :: Serialize,
3175 Clone,
3176 Debug,
3177 Eq,
3178 Hash,
3179 Ord,
3180 PartialEq,
3181 PartialOrd,
3182 )]
3183 #[serde(transparent)]
3184 pub struct Plan(pub ::std::string::String);
3185 impl ::std::ops::Deref for Plan {
3186 type Target = ::std::string::String;
3187 fn deref(&self) -> &::std::string::String {
3188 &self.0
3189 }
3190 }
3191
3192 impl ::std::convert::From<Plan> for ::std::string::String {
3193 fn from(value: Plan) -> Self {
3194 value.0
3195 }
3196 }
3197
3198 impl ::std::convert::From<::std::string::String> for Plan {
3199 fn from(value: ::std::string::String) -> Self {
3200 Self(value)
3201 }
3202 }
3203
3204 impl ::std::str::FromStr for Plan {
3205 type Err = ::std::convert::Infallible;
3206 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
3207 Ok(Self(value.to_string()))
3208 }
3209 }
3210
3211 impl ::std::fmt::Display for Plan {
3212 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3213 self.0.fmt(f)
3214 }
3215 }
3216
3217 ///`Postgres`
3218 ///
3219 /// <details><summary>JSON schema</summary>
3220 ///
3221 /// ```json
3222 ///{
3223 /// "type": "object",
3224 /// "properties": {
3225 /// "createdAt": {
3226 /// "type": "string",
3227 /// "format": "date-time"
3228 /// },
3229 /// "dashboardUrl": {
3230 /// "description": "The URL to view the Postgres instance in the Render
3231 /// Dashboard",
3232 /// "type": "string"
3233 /// },
3234 /// "databaseName": {
3235 /// "type": "string"
3236 /// },
3237 /// "databaseUser": {
3238 /// "type": "string"
3239 /// },
3240 /// "diskAutoscalingEnabled": {
3241 /// "type": "boolean"
3242 /// },
3243 /// "diskSizeGB": {
3244 /// "type": "integer"
3245 /// },
3246 /// "environmentId": {
3247 /// "type": "string"
3248 /// },
3249 /// "expiresAt": {
3250 /// "description": "The time at which the database will be expire.
3251 /// Applies to free tier databases only.",
3252 /// "type": "string",
3253 /// "format": "date-time"
3254 /// },
3255 /// "highAvailabilityEnabled": {
3256 /// "type": "boolean"
3257 /// },
3258 /// "id": {
3259 /// "type": "string"
3260 /// },
3261 /// "ipAllowList": {
3262 /// "type": "array",
3263 /// "items": {
3264 /// "$ref": "#/components/schemas/cidrBlockAndDescription"
3265 /// }
3266 /// },
3267 /// "name": {
3268 /// "type": "string"
3269 /// },
3270 /// "owner": {
3271 /// "$ref": "#/components/schemas/owner"
3272 /// },
3273 /// "plan": {
3274 /// "type": "string"
3275 /// },
3276 /// "primaryPostgresID": {
3277 /// "type": "string"
3278 /// },
3279 /// "readReplicas": {
3280 /// "$ref": "#/components/schemas/readReplicas"
3281 /// },
3282 /// "region": {
3283 /// "$ref": "#/components/schemas/region"
3284 /// },
3285 /// "role": {
3286 /// "$ref": "#/components/schemas/databaseRole"
3287 /// },
3288 /// "status": {
3289 /// "$ref": "#/components/schemas/databaseStatus"
3290 /// },
3291 /// "suspended": {
3292 /// "type": "string"
3293 /// },
3294 /// "suspenders": {
3295 /// "type": "array",
3296 /// "items": {
3297 /// "$ref": "#/components/schemas/suspenderType"
3298 /// }
3299 /// },
3300 /// "updatedAt": {
3301 /// "type": "string",
3302 /// "format": "date-time"
3303 /// },
3304 /// "version": {
3305 /// "$ref": "#/components/schemas/postgresVersion"
3306 /// }
3307 /// }
3308 ///}
3309 /// ```
3310 /// </details>
3311 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3312 pub struct Postgres {
3313 #[serde(
3314 rename = "createdAt",
3315 default,
3316 skip_serializing_if = "::std::option::Option::is_none"
3317 )]
3318 pub created_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
3319 ///The URL to view the Postgres instance in the Render Dashboard
3320 #[serde(
3321 rename = "dashboardUrl",
3322 default,
3323 skip_serializing_if = "::std::option::Option::is_none"
3324 )]
3325 pub dashboard_url: ::std::option::Option<::std::string::String>,
3326 #[serde(
3327 rename = "databaseName",
3328 default,
3329 skip_serializing_if = "::std::option::Option::is_none"
3330 )]
3331 pub database_name: ::std::option::Option<::std::string::String>,
3332 #[serde(
3333 rename = "databaseUser",
3334 default,
3335 skip_serializing_if = "::std::option::Option::is_none"
3336 )]
3337 pub database_user: ::std::option::Option<::std::string::String>,
3338 #[serde(
3339 rename = "diskAutoscalingEnabled",
3340 default,
3341 skip_serializing_if = "::std::option::Option::is_none"
3342 )]
3343 pub disk_autoscaling_enabled: ::std::option::Option<bool>,
3344 #[serde(
3345 rename = "diskSizeGB",
3346 default,
3347 skip_serializing_if = "::std::option::Option::is_none"
3348 )]
3349 pub disk_size_gb: ::std::option::Option<i64>,
3350 #[serde(
3351 rename = "environmentId",
3352 default,
3353 skip_serializing_if = "::std::option::Option::is_none"
3354 )]
3355 pub environment_id: ::std::option::Option<::std::string::String>,
3356 ///The time at which the database will be expire. Applies to free tier
3357 /// databases only.
3358 #[serde(
3359 rename = "expiresAt",
3360 default,
3361 skip_serializing_if = "::std::option::Option::is_none"
3362 )]
3363 pub expires_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
3364 #[serde(
3365 rename = "highAvailabilityEnabled",
3366 default,
3367 skip_serializing_if = "::std::option::Option::is_none"
3368 )]
3369 pub high_availability_enabled: ::std::option::Option<bool>,
3370 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3371 pub id: ::std::option::Option<::std::string::String>,
3372 #[serde(
3373 rename = "ipAllowList",
3374 default,
3375 skip_serializing_if = "::std::vec::Vec::is_empty"
3376 )]
3377 pub ip_allow_list: ::std::vec::Vec<CidrBlockAndDescription>,
3378 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3379 pub name: ::std::option::Option<::std::string::String>,
3380 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3381 pub owner: ::std::option::Option<Owner>,
3382 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3383 pub plan: ::std::option::Option<::std::string::String>,
3384 #[serde(
3385 rename = "primaryPostgresID",
3386 default,
3387 skip_serializing_if = "::std::option::Option::is_none"
3388 )]
3389 pub primary_postgres_id: ::std::option::Option<::std::string::String>,
3390 #[serde(
3391 rename = "readReplicas",
3392 default,
3393 skip_serializing_if = "::std::option::Option::is_none"
3394 )]
3395 pub read_replicas: ::std::option::Option<ReadReplicas>,
3396 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3397 pub region: ::std::option::Option<Region>,
3398 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3399 pub role: ::std::option::Option<DatabaseRole>,
3400 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3401 pub status: ::std::option::Option<DatabaseStatus>,
3402 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3403 pub suspended: ::std::option::Option<::std::string::String>,
3404 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
3405 pub suspenders: ::std::vec::Vec<SuspenderType>,
3406 #[serde(
3407 rename = "updatedAt",
3408 default,
3409 skip_serializing_if = "::std::option::Option::is_none"
3410 )]
3411 pub updated_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
3412 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3413 pub version: ::std::option::Option<PostgresVersion>,
3414 }
3415
3416 impl ::std::default::Default for Postgres {
3417 fn default() -> Self {
3418 Self {
3419 created_at: Default::default(),
3420 dashboard_url: Default::default(),
3421 database_name: Default::default(),
3422 database_user: Default::default(),
3423 disk_autoscaling_enabled: Default::default(),
3424 disk_size_gb: Default::default(),
3425 environment_id: Default::default(),
3426 expires_at: Default::default(),
3427 high_availability_enabled: Default::default(),
3428 id: Default::default(),
3429 ip_allow_list: Default::default(),
3430 name: Default::default(),
3431 owner: Default::default(),
3432 plan: Default::default(),
3433 primary_postgres_id: Default::default(),
3434 read_replicas: Default::default(),
3435 region: Default::default(),
3436 role: Default::default(),
3437 status: Default::default(),
3438 suspended: Default::default(),
3439 suspenders: Default::default(),
3440 updated_at: Default::default(),
3441 version: Default::default(),
3442 }
3443 }
3444 }
3445
3446 ///`PostgresConnectionInfo`
3447 ///
3448 /// <details><summary>JSON schema</summary>
3449 ///
3450 /// ```json
3451 ///{
3452 /// "type": "object",
3453 /// "properties": {
3454 /// "externalConnectionString": {
3455 /// "type": "string",
3456 /// "format": "password"
3457 /// },
3458 /// "internalConnectionString": {
3459 /// "type": "string",
3460 /// "format": "password"
3461 /// },
3462 /// "password": {
3463 /// "type": "string",
3464 /// "format": "password"
3465 /// },
3466 /// "psqlCommand": {
3467 /// "type": "string",
3468 /// "format": "password"
3469 /// }
3470 /// }
3471 ///}
3472 /// ```
3473 /// </details>
3474 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3475 pub struct PostgresConnectionInfo {
3476 #[serde(
3477 rename = "externalConnectionString",
3478 default,
3479 skip_serializing_if = "::std::option::Option::is_none"
3480 )]
3481 pub external_connection_string: ::std::option::Option<::std::string::String>,
3482 #[serde(
3483 rename = "internalConnectionString",
3484 default,
3485 skip_serializing_if = "::std::option::Option::is_none"
3486 )]
3487 pub internal_connection_string: ::std::option::Option<::std::string::String>,
3488 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3489 pub password: ::std::option::Option<::std::string::String>,
3490 #[serde(
3491 rename = "psqlCommand",
3492 default,
3493 skip_serializing_if = "::std::option::Option::is_none"
3494 )]
3495 pub psql_command: ::std::option::Option<::std::string::String>,
3496 }
3497
3498 impl ::std::default::Default for PostgresConnectionInfo {
3499 fn default() -> Self {
3500 Self {
3501 external_connection_string: Default::default(),
3502 internal_connection_string: Default::default(),
3503 password: Default::default(),
3504 psql_command: Default::default(),
3505 }
3506 }
3507 }
3508
3509 ///`PostgresDetail`
3510 ///
3511 /// <details><summary>JSON schema</summary>
3512 ///
3513 /// ```json
3514 ///{
3515 /// "type": "object",
3516 /// "properties": {
3517 /// "createdAt": {
3518 /// "type": "string",
3519 /// "format": "date-time"
3520 /// },
3521 /// "dashboardUrl": {
3522 /// "description": "The URL to view the Postgres instance in the Render
3523 /// Dashboard",
3524 /// "type": "string"
3525 /// },
3526 /// "databaseName": {
3527 /// "type": "string"
3528 /// },
3529 /// "databaseUser": {
3530 /// "type": "string"
3531 /// },
3532 /// "diskAutoscalingEnabled": {
3533 /// "type": "boolean"
3534 /// },
3535 /// "diskSizeGB": {
3536 /// "type": "integer"
3537 /// },
3538 /// "environmentId": {
3539 /// "type": "string"
3540 /// },
3541 /// "expiresAt": {
3542 /// "description": "The time at which the database will be expire.
3543 /// Applies to free tier databases only.",
3544 /// "type": "string",
3545 /// "format": "date-time"
3546 /// },
3547 /// "highAvailabilityEnabled": {
3548 /// "type": "boolean"
3549 /// },
3550 /// "id": {
3551 /// "type": "string"
3552 /// },
3553 /// "ipAllowList": {
3554 /// "type": "array",
3555 /// "items": {
3556 /// "$ref": "#/components/schemas/cidrBlockAndDescription"
3557 /// }
3558 /// },
3559 /// "maintenance": {
3560 /// "type": "object",
3561 /// "properties": {
3562 /// "id": {
3563 /// "examples": [
3564 /// "mrn-cph1rs3idesc73a2b2mg"
3565 /// ],
3566 /// "type": "string",
3567 /// "pattern": "^mrn-[0-9a-z]{20}$"
3568 /// },
3569 /// "pendingMaintenanceBy": {
3570 /// "description": "If present, the maintenance run cannot be
3571 /// scheduled for later than this date-time.",
3572 /// "type": "string",
3573 /// "format": "date-time"
3574 /// },
3575 /// "scheduledAt": {
3576 /// "type": "string",
3577 /// "format": "date-time"
3578 /// },
3579 /// "state": {
3580 /// "type": "string"
3581 /// },
3582 /// "type": {
3583 /// "type": "string"
3584 /// }
3585 /// }
3586 /// },
3587 /// "name": {
3588 /// "type": "string"
3589 /// },
3590 /// "owner": {
3591 /// "$ref": "#/components/schemas/owner"
3592 /// },
3593 /// "parameterOverrides": {
3594 /// "$ref": "#/components/schemas/postgresParameterOverrides"
3595 /// },
3596 /// "plan": {
3597 /// "type": "string"
3598 /// },
3599 /// "primaryPostgresID": {
3600 /// "type": "string"
3601 /// },
3602 /// "readReplicas": {
3603 /// "$ref": "#/components/schemas/readReplicas"
3604 /// },
3605 /// "region": {
3606 /// "$ref": "#/components/schemas/region"
3607 /// },
3608 /// "role": {
3609 /// "$ref": "#/components/schemas/databaseRole"
3610 /// },
3611 /// "status": {
3612 /// "$ref": "#/components/schemas/databaseStatus"
3613 /// },
3614 /// "suspended": {
3615 /// "type": "string"
3616 /// },
3617 /// "suspenders": {
3618 /// "type": "array",
3619 /// "items": {
3620 /// "$ref": "#/components/schemas/suspenderType"
3621 /// }
3622 /// },
3623 /// "updatedAt": {
3624 /// "type": "string",
3625 /// "format": "date-time"
3626 /// },
3627 /// "version": {
3628 /// "$ref": "#/components/schemas/postgresVersion"
3629 /// }
3630 /// }
3631 ///}
3632 /// ```
3633 /// </details>
3634 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3635 pub struct PostgresDetail {
3636 #[serde(
3637 rename = "createdAt",
3638 default,
3639 skip_serializing_if = "::std::option::Option::is_none"
3640 )]
3641 pub created_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
3642 ///The URL to view the Postgres instance in the Render Dashboard
3643 #[serde(
3644 rename = "dashboardUrl",
3645 default,
3646 skip_serializing_if = "::std::option::Option::is_none"
3647 )]
3648 pub dashboard_url: ::std::option::Option<::std::string::String>,
3649 #[serde(
3650 rename = "databaseName",
3651 default,
3652 skip_serializing_if = "::std::option::Option::is_none"
3653 )]
3654 pub database_name: ::std::option::Option<::std::string::String>,
3655 #[serde(
3656 rename = "databaseUser",
3657 default,
3658 skip_serializing_if = "::std::option::Option::is_none"
3659 )]
3660 pub database_user: ::std::option::Option<::std::string::String>,
3661 #[serde(
3662 rename = "diskAutoscalingEnabled",
3663 default,
3664 skip_serializing_if = "::std::option::Option::is_none"
3665 )]
3666 pub disk_autoscaling_enabled: ::std::option::Option<bool>,
3667 #[serde(
3668 rename = "diskSizeGB",
3669 default,
3670 skip_serializing_if = "::std::option::Option::is_none"
3671 )]
3672 pub disk_size_gb: ::std::option::Option<i64>,
3673 #[serde(
3674 rename = "environmentId",
3675 default,
3676 skip_serializing_if = "::std::option::Option::is_none"
3677 )]
3678 pub environment_id: ::std::option::Option<::std::string::String>,
3679 ///The time at which the database will be expire. Applies to free tier
3680 /// databases only.
3681 #[serde(
3682 rename = "expiresAt",
3683 default,
3684 skip_serializing_if = "::std::option::Option::is_none"
3685 )]
3686 pub expires_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
3687 #[serde(
3688 rename = "highAvailabilityEnabled",
3689 default,
3690 skip_serializing_if = "::std::option::Option::is_none"
3691 )]
3692 pub high_availability_enabled: ::std::option::Option<bool>,
3693 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3694 pub id: ::std::option::Option<::std::string::String>,
3695 #[serde(
3696 rename = "ipAllowList",
3697 default,
3698 skip_serializing_if = "::std::vec::Vec::is_empty"
3699 )]
3700 pub ip_allow_list: ::std::vec::Vec<CidrBlockAndDescription>,
3701 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3702 pub maintenance: ::std::option::Option<PostgresDetailMaintenance>,
3703 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3704 pub name: ::std::option::Option<::std::string::String>,
3705 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3706 pub owner: ::std::option::Option<Owner>,
3707 #[serde(
3708 rename = "parameterOverrides",
3709 default,
3710 skip_serializing_if = "::std::option::Option::is_none"
3711 )]
3712 pub parameter_overrides: ::std::option::Option<PostgresParameterOverrides>,
3713 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3714 pub plan: ::std::option::Option<::std::string::String>,
3715 #[serde(
3716 rename = "primaryPostgresID",
3717 default,
3718 skip_serializing_if = "::std::option::Option::is_none"
3719 )]
3720 pub primary_postgres_id: ::std::option::Option<::std::string::String>,
3721 #[serde(
3722 rename = "readReplicas",
3723 default,
3724 skip_serializing_if = "::std::option::Option::is_none"
3725 )]
3726 pub read_replicas: ::std::option::Option<ReadReplicas>,
3727 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3728 pub region: ::std::option::Option<Region>,
3729 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3730 pub role: ::std::option::Option<DatabaseRole>,
3731 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3732 pub status: ::std::option::Option<DatabaseStatus>,
3733 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3734 pub suspended: ::std::option::Option<::std::string::String>,
3735 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
3736 pub suspenders: ::std::vec::Vec<SuspenderType>,
3737 #[serde(
3738 rename = "updatedAt",
3739 default,
3740 skip_serializing_if = "::std::option::Option::is_none"
3741 )]
3742 pub updated_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
3743 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3744 pub version: ::std::option::Option<PostgresVersion>,
3745 }
3746
3747 impl ::std::default::Default for PostgresDetail {
3748 fn default() -> Self {
3749 Self {
3750 created_at: Default::default(),
3751 dashboard_url: Default::default(),
3752 database_name: Default::default(),
3753 database_user: Default::default(),
3754 disk_autoscaling_enabled: Default::default(),
3755 disk_size_gb: Default::default(),
3756 environment_id: Default::default(),
3757 expires_at: Default::default(),
3758 high_availability_enabled: Default::default(),
3759 id: Default::default(),
3760 ip_allow_list: Default::default(),
3761 maintenance: Default::default(),
3762 name: Default::default(),
3763 owner: Default::default(),
3764 parameter_overrides: Default::default(),
3765 plan: Default::default(),
3766 primary_postgres_id: Default::default(),
3767 read_replicas: Default::default(),
3768 region: Default::default(),
3769 role: Default::default(),
3770 status: Default::default(),
3771 suspended: Default::default(),
3772 suspenders: Default::default(),
3773 updated_at: Default::default(),
3774 version: Default::default(),
3775 }
3776 }
3777 }
3778
3779 ///`PostgresDetailMaintenance`
3780 ///
3781 /// <details><summary>JSON schema</summary>
3782 ///
3783 /// ```json
3784 ///{
3785 /// "type": "object",
3786 /// "properties": {
3787 /// "id": {
3788 /// "examples": [
3789 /// "mrn-cph1rs3idesc73a2b2mg"
3790 /// ],
3791 /// "type": "string",
3792 /// "pattern": "^mrn-[0-9a-z]{20}$"
3793 /// },
3794 /// "pendingMaintenanceBy": {
3795 /// "description": "If present, the maintenance run cannot be scheduled
3796 /// for later than this date-time.",
3797 /// "type": "string",
3798 /// "format": "date-time"
3799 /// },
3800 /// "scheduledAt": {
3801 /// "type": "string",
3802 /// "format": "date-time"
3803 /// },
3804 /// "state": {
3805 /// "type": "string"
3806 /// },
3807 /// "type": {
3808 /// "type": "string"
3809 /// }
3810 /// }
3811 ///}
3812 /// ```
3813 /// </details>
3814 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3815 pub struct PostgresDetailMaintenance {
3816 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3817 pub id: ::std::option::Option<PostgresDetailMaintenanceId>,
3818 ///If present, the maintenance run cannot be scheduled for later than
3819 /// this date-time.
3820 #[serde(
3821 rename = "pendingMaintenanceBy",
3822 default,
3823 skip_serializing_if = "::std::option::Option::is_none"
3824 )]
3825 pub pending_maintenance_by:
3826 ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
3827 #[serde(
3828 rename = "scheduledAt",
3829 default,
3830 skip_serializing_if = "::std::option::Option::is_none"
3831 )]
3832 pub scheduled_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
3833 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
3834 pub state: ::std::option::Option<::std::string::String>,
3835 #[serde(
3836 rename = "type",
3837 default,
3838 skip_serializing_if = "::std::option::Option::is_none"
3839 )]
3840 pub type_: ::std::option::Option<::std::string::String>,
3841 }
3842
3843 impl ::std::default::Default for PostgresDetailMaintenance {
3844 fn default() -> Self {
3845 Self {
3846 id: Default::default(),
3847 pending_maintenance_by: Default::default(),
3848 scheduled_at: Default::default(),
3849 state: Default::default(),
3850 type_: Default::default(),
3851 }
3852 }
3853 }
3854
3855 ///`PostgresDetailMaintenanceId`
3856 ///
3857 /// <details><summary>JSON schema</summary>
3858 ///
3859 /// ```json
3860 ///{
3861 /// "examples": [
3862 /// "mrn-cph1rs3idesc73a2b2mg"
3863 /// ],
3864 /// "type": "string",
3865 /// "pattern": "^mrn-[0-9a-z]{20}$"
3866 ///}
3867 /// ```
3868 /// </details>
3869 #[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
3870 #[serde(transparent)]
3871 pub struct PostgresDetailMaintenanceId(::std::string::String);
3872 impl ::std::ops::Deref for PostgresDetailMaintenanceId {
3873 type Target = ::std::string::String;
3874 fn deref(&self) -> &::std::string::String {
3875 &self.0
3876 }
3877 }
3878
3879 impl ::std::convert::From<PostgresDetailMaintenanceId> for ::std::string::String {
3880 fn from(value: PostgresDetailMaintenanceId) -> Self {
3881 value.0
3882 }
3883 }
3884
3885 impl ::std::str::FromStr for PostgresDetailMaintenanceId {
3886 type Err = self::error::ConversionError;
3887 fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3888 static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
3889 ::std::sync::LazyLock::new(|| ::regress::Regex::new("^mrn-[0-9a-z]{20}$").unwrap());
3890 if PATTERN.find(value).is_none() {
3891 return Err("doesn't match pattern \"^mrn-[0-9a-z]{20}$\"".into());
3892 }
3893 Ok(Self(value.to_string()))
3894 }
3895 }
3896
3897 impl ::std::convert::TryFrom<&str> for PostgresDetailMaintenanceId {
3898 type Error = self::error::ConversionError;
3899 fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
3900 value.parse()
3901 }
3902 }
3903
3904 impl ::std::convert::TryFrom<&::std::string::String> for PostgresDetailMaintenanceId {
3905 type Error = self::error::ConversionError;
3906 fn try_from(
3907 value: &::std::string::String,
3908 ) -> ::std::result::Result<Self, self::error::ConversionError> {
3909 value.parse()
3910 }
3911 }
3912
3913 impl ::std::convert::TryFrom<::std::string::String> for PostgresDetailMaintenanceId {
3914 type Error = self::error::ConversionError;
3915 fn try_from(
3916 value: ::std::string::String,
3917 ) -> ::std::result::Result<Self, self::error::ConversionError> {
3918 value.parse()
3919 }
3920 }
3921
3922 impl<'de> ::serde::Deserialize<'de> for PostgresDetailMaintenanceId {
3923 fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
3924 where
3925 D: ::serde::Deserializer<'de>,
3926 {
3927 ::std::string::String::deserialize(deserializer)?
3928 .parse()
3929 .map_err(|e: self::error::ConversionError| {
3930 <D::Error as ::serde::de::Error>::custom(e.to_string())
3931 })
3932 }
3933 }
3934
3935 ///`PostgresParameterOverrides`
3936 ///
3937 /// <details><summary>JSON schema</summary>
3938 ///
3939 /// ```json
3940 ///{
3941 /// "type": "object",
3942 /// "additionalProperties": {
3943 /// "type": "string"
3944 /// }
3945 ///}
3946 /// ```
3947 /// </details>
3948 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
3949 #[serde(transparent)]
3950 pub struct PostgresParameterOverrides(
3951 pub ::std::collections::HashMap<::std::string::String, ::std::string::String>,
3952 );
3953 impl ::std::ops::Deref for PostgresParameterOverrides {
3954 type Target = ::std::collections::HashMap<::std::string::String, ::std::string::String>;
3955 fn deref(
3956 &self,
3957 ) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
3958 &self.0
3959 }
3960 }
3961
3962 impl ::std::convert::From<PostgresParameterOverrides>
3963 for ::std::collections::HashMap<::std::string::String, ::std::string::String>
3964 {
3965 fn from(value: PostgresParameterOverrides) -> Self {
3966 value.0
3967 }
3968 }
3969
3970 impl
3971 ::std::convert::From<
3972 ::std::collections::HashMap<::std::string::String, ::std::string::String>,
3973 > for PostgresParameterOverrides
3974 {
3975 fn from(
3976 value: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
3977 ) -> Self {
3978 Self(value)
3979 }
3980 }
3981
3982 ///Input for creating a database
3983 ///
3984 /// <details><summary>JSON schema</summary>
3985 ///
3986 /// ```json
3987 ///{
3988 /// "description": "Input for creating a database",
3989 /// "type": "object",
3990 /// "properties": {
3991 /// "databaseName": {
3992 /// "default": "randomly generated",
3993 /// "type": "string"
3994 /// },
3995 /// "databaseUser": {
3996 /// "default": "randomly generated",
3997 /// "type": "string"
3998 /// },
3999 /// "datadogAPIKey": {
4000 /// "description": "The Datadog API key for the Datadog agent to
4001 /// monitor the new database.",
4002 /// "type": "string"
4003 /// },
4004 /// "datadogSite": {
4005 /// "description": "Datadog region to use for monitoring the new
4006 /// database. Defaults to 'US1'.",
4007 /// "examples": [
4008 /// "US1"
4009 /// ],
4010 /// "type": "string"
4011 /// },
4012 /// "diskSizeGB": {
4013 /// "description": "The number of gigabytes of disk space to allocate
4014 /// for the database",
4015 /// "type": "integer"
4016 /// },
4017 /// "enableDiskAutoscaling": {
4018 /// "default": false,
4019 /// "type": "boolean"
4020 /// },
4021 /// "enableHighAvailability": {
4022 /// "default": false,
4023 /// "type": "boolean"
4024 /// },
4025 /// "environmentId": {
4026 /// "type": "string"
4027 /// },
4028 /// "ipAllowList": {
4029 /// "type": "array",
4030 /// "items": {
4031 /// "$ref": "#/components/schemas/cidrBlockAndDescription"
4032 /// }
4033 /// },
4034 /// "name": {
4035 /// "description": "The name of the database as it will appear in the
4036 /// Render Dashboard",
4037 /// "type": "string"
4038 /// },
4039 /// "ownerId": {
4040 /// "description": "The ID of the workspace to create the database
4041 /// for",
4042 /// "type": "string"
4043 /// },
4044 /// "parameterOverrides": {
4045 /// "$ref": "#/components/schemas/postgresParameterOverrides"
4046 /// },
4047 /// "plan": {
4048 /// "type": "string"
4049 /// },
4050 /// "readReplicas": {
4051 /// "$ref": "#/components/schemas/readReplicasInput"
4052 /// },
4053 /// "region": {
4054 /// "$ref": "#/components/schemas/region"
4055 /// },
4056 /// "version": {
4057 /// "$ref": "#/components/schemas/postgresVersion"
4058 /// }
4059 /// }
4060 ///}
4061 /// ```
4062 /// </details>
4063 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4064 pub struct PostgresPostInput {
4065 #[serde(
4066 rename = "databaseName",
4067 default = "defaults::postgres_post_input_database_name"
4068 )]
4069 pub database_name: ::std::string::String,
4070 #[serde(
4071 rename = "databaseUser",
4072 default = "defaults::postgres_post_input_database_user"
4073 )]
4074 pub database_user: ::std::string::String,
4075 ///The Datadog API key for the Datadog agent to monitor the new
4076 /// database.
4077 #[serde(
4078 rename = "datadogAPIKey",
4079 default,
4080 skip_serializing_if = "::std::option::Option::is_none"
4081 )]
4082 pub datadog_api_key: ::std::option::Option<::std::string::String>,
4083 ///Datadog region to use for monitoring the new database. Defaults to
4084 /// 'US1'.
4085 #[serde(
4086 rename = "datadogSite",
4087 default,
4088 skip_serializing_if = "::std::option::Option::is_none"
4089 )]
4090 pub datadog_site: ::std::option::Option<::std::string::String>,
4091 ///The number of gigabytes of disk space to allocate for the database
4092 #[serde(
4093 rename = "diskSizeGB",
4094 default,
4095 skip_serializing_if = "::std::option::Option::is_none"
4096 )]
4097 pub disk_size_gb: ::std::option::Option<i64>,
4098 #[serde(rename = "enableDiskAutoscaling", default)]
4099 pub enable_disk_autoscaling: bool,
4100 #[serde(rename = "enableHighAvailability", default)]
4101 pub enable_high_availability: bool,
4102 #[serde(
4103 rename = "environmentId",
4104 default,
4105 skip_serializing_if = "::std::option::Option::is_none"
4106 )]
4107 pub environment_id: ::std::option::Option<::std::string::String>,
4108 #[serde(
4109 rename = "ipAllowList",
4110 default,
4111 skip_serializing_if = "::std::vec::Vec::is_empty"
4112 )]
4113 pub ip_allow_list: ::std::vec::Vec<CidrBlockAndDescription>,
4114 ///The name of the database as it will appear in the Render Dashboard
4115 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4116 pub name: ::std::option::Option<::std::string::String>,
4117 ///The ID of the workspace to create the database for
4118 #[serde(
4119 rename = "ownerId",
4120 default,
4121 skip_serializing_if = "::std::option::Option::is_none"
4122 )]
4123 pub owner_id: ::std::option::Option<::std::string::String>,
4124 #[serde(
4125 rename = "parameterOverrides",
4126 default,
4127 skip_serializing_if = "::std::option::Option::is_none"
4128 )]
4129 pub parameter_overrides: ::std::option::Option<PostgresParameterOverrides>,
4130 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4131 pub plan: ::std::option::Option<::std::string::String>,
4132 #[serde(
4133 rename = "readReplicas",
4134 default,
4135 skip_serializing_if = "::std::option::Option::is_none"
4136 )]
4137 pub read_replicas: ::std::option::Option<ReadReplicasInput>,
4138 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4139 pub region: ::std::option::Option<Region>,
4140 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4141 pub version: ::std::option::Option<PostgresVersion>,
4142 }
4143
4144 impl ::std::default::Default for PostgresPostInput {
4145 fn default() -> Self {
4146 Self {
4147 database_name: defaults::postgres_post_input_database_name(),
4148 database_user: defaults::postgres_post_input_database_user(),
4149 datadog_api_key: Default::default(),
4150 datadog_site: Default::default(),
4151 disk_size_gb: Default::default(),
4152 enable_disk_autoscaling: Default::default(),
4153 enable_high_availability: Default::default(),
4154 environment_id: Default::default(),
4155 ip_allow_list: Default::default(),
4156 name: Default::default(),
4157 owner_id: Default::default(),
4158 parameter_overrides: Default::default(),
4159 plan: Default::default(),
4160 read_replicas: Default::default(),
4161 region: Default::default(),
4162 version: Default::default(),
4163 }
4164 }
4165 }
4166
4167 ///The PostgreSQL version
4168 ///
4169 /// <details><summary>JSON schema</summary>
4170 ///
4171 /// ```json
4172 ///{
4173 /// "description": "The PostgreSQL version",
4174 /// "type": "string"
4175 ///}
4176 /// ```
4177 /// </details>
4178 #[derive(
4179 :: serde :: Deserialize,
4180 :: serde :: Serialize,
4181 Clone,
4182 Debug,
4183 Eq,
4184 Hash,
4185 Ord,
4186 PartialEq,
4187 PartialOrd,
4188 )]
4189 #[serde(transparent)]
4190 pub struct PostgresVersion(pub ::std::string::String);
4191 impl ::std::ops::Deref for PostgresVersion {
4192 type Target = ::std::string::String;
4193 fn deref(&self) -> &::std::string::String {
4194 &self.0
4195 }
4196 }
4197
4198 impl ::std::convert::From<PostgresVersion> for ::std::string::String {
4199 fn from(value: PostgresVersion) -> Self {
4200 value.0
4201 }
4202 }
4203
4204 impl ::std::convert::From<::std::string::String> for PostgresVersion {
4205 fn from(value: ::std::string::String) -> Self {
4206 Self(value)
4207 }
4208 }
4209
4210 impl ::std::str::FromStr for PostgresVersion {
4211 type Err = ::std::convert::Infallible;
4212 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
4213 Ok(Self(value.to_string()))
4214 }
4215 }
4216
4217 impl ::std::fmt::Display for PostgresVersion {
4218 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4219 self.0.fmt(f)
4220 }
4221 }
4222
4223 ///`PostgresWithCursor`
4224 ///
4225 /// <details><summary>JSON schema</summary>
4226 ///
4227 /// ```json
4228 ///{
4229 /// "type": "object",
4230 /// "properties": {
4231 /// "cursor": {
4232 /// "$ref": "#/components/schemas/cursor"
4233 /// },
4234 /// "postgres": {
4235 /// "$ref": "#/components/schemas/postgres"
4236 /// }
4237 /// }
4238 ///}
4239 /// ```
4240 /// </details>
4241 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4242 pub struct PostgresWithCursor {
4243 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4244 pub cursor: ::std::option::Option<Cursor>,
4245 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4246 pub postgres: ::std::option::Option<Postgres>,
4247 }
4248
4249 impl ::std::default::Default for PostgresWithCursor {
4250 fn default() -> Self {
4251 Self {
4252 cursor: Default::default(),
4253 postgres: Default::default(),
4254 }
4255 }
4256 }
4257
4258 ///`Previews`
4259 ///
4260 /// <details><summary>JSON schema</summary>
4261 ///
4262 /// ```json
4263 ///{
4264 /// "type": "object",
4265 /// "properties": {
4266 /// "generation": {
4267 /// "description": "Defaults to \"off\"",
4268 /// "default": "off",
4269 /// "type": "string"
4270 /// }
4271 /// }
4272 ///}
4273 /// ```
4274 /// </details>
4275 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4276 pub struct Previews {
4277 ///Defaults to "off"
4278 #[serde(default = "defaults::previews_generation")]
4279 pub generation: ::std::string::String,
4280 }
4281
4282 impl ::std::default::Default for Previews {
4283 fn default() -> Self {
4284 Self {
4285 generation: defaults::previews_generation(),
4286 }
4287 }
4288 }
4289
4290 ///`PrivateServiceDetails`
4291 ///
4292 /// <details><summary>JSON schema</summary>
4293 ///
4294 /// ```json
4295 ///{
4296 /// "type": "object",
4297 /// "properties": {
4298 /// "autoscaling": {
4299 /// "type": "object",
4300 /// "properties": {
4301 /// "criteria": {
4302 /// "type": "object",
4303 /// "properties": {
4304 /// "cpu": {
4305 /// "type": "object",
4306 /// "properties": {
4307 /// "enabled": {
4308 /// "default": false,
4309 /// "type": "boolean"
4310 /// },
4311 /// "percentage": {
4312 /// "description": "Determines when your service will be
4313 /// scaled. If the average resource utilization is significantly above/below
4314 /// the target, we will increase/decrease the number of instances.\n",
4315 /// "type": "integer"
4316 /// }
4317 /// }
4318 /// },
4319 /// "memory": {
4320 /// "type": "object",
4321 /// "properties": {
4322 /// "enabled": {
4323 /// "default": false,
4324 /// "type": "boolean"
4325 /// },
4326 /// "percentage": {
4327 /// "description": "Determines when your service will be
4328 /// scaled. If the average resource utilization is significantly above/below
4329 /// the target, we will increase/decrease the number of instances.\n",
4330 /// "type": "integer"
4331 /// }
4332 /// }
4333 /// }
4334 /// }
4335 /// },
4336 /// "enabled": {
4337 /// "default": false,
4338 /// "type": "boolean"
4339 /// },
4340 /// "max": {
4341 /// "description": "The maximum number of instances for the
4342 /// service",
4343 /// "type": "integer"
4344 /// },
4345 /// "min": {
4346 /// "description": "The minimum number of instances for the
4347 /// service",
4348 /// "type": "integer"
4349 /// }
4350 /// }
4351 /// },
4352 /// "buildPlan": {
4353 /// "$ref": "#/components/schemas/buildPlan"
4354 /// },
4355 /// "disk": {
4356 /// "type": "object",
4357 /// "properties": {
4358 /// "id": {
4359 /// "examples": [
4360 /// "dsk-cph1rs3idesc73a2b2mg"
4361 /// ],
4362 /// "type": "string",
4363 /// "pattern": "^dsk-[0-9a-z]{20}$"
4364 /// },
4365 /// "mountPath": {
4366 /// "type": "string"
4367 /// },
4368 /// "name": {
4369 /// "type": "string"
4370 /// },
4371 /// "sizeGB": {
4372 /// "type": "integer"
4373 /// }
4374 /// }
4375 /// },
4376 /// "env": {
4377 /// "$ref": "#/components/schemas/serviceEnv"
4378 /// },
4379 /// "envSpecificDetails": {
4380 /// "$ref": "#/components/schemas/envSpecificDetails"
4381 /// },
4382 /// "maxShutdownDelaySeconds": {
4383 /// "$ref": "#/components/schemas/maxShutdownDelaySeconds"
4384 /// },
4385 /// "numInstances": {
4386 /// "description": "For a *manually* scaled service, this is the number
4387 /// of instances the service is scaled to. DOES NOT indicate the number of
4388 /// running instances for an *autoscaled* service.",
4389 /// "type": "integer"
4390 /// },
4391 /// "openPorts": {
4392 /// "type": "array",
4393 /// "items": {
4394 /// "$ref": "#/components/schemas/serverPort"
4395 /// }
4396 /// },
4397 /// "parentServer": {
4398 /// "$ref": "#/components/schemas/resource"
4399 /// },
4400 /// "plan": {
4401 /// "$ref": "#/components/schemas/plan"
4402 /// },
4403 /// "previews": {
4404 /// "$ref": "#/components/schemas/previews"
4405 /// },
4406 /// "pullRequestPreviewsEnabled": {
4407 /// "$ref": "#/components/schemas/pullRequestPreviewsEnabled"
4408 /// },
4409 /// "region": {
4410 /// "$ref": "#/components/schemas/region"
4411 /// },
4412 /// "runtime": {
4413 /// "$ref": "#/components/schemas/serviceRuntime"
4414 /// },
4415 /// "sshAddress": {
4416 /// "$ref": "#/components/schemas/sshAddress"
4417 /// },
4418 /// "url": {
4419 /// "type": "string"
4420 /// }
4421 /// }
4422 ///}
4423 /// ```
4424 /// </details>
4425 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4426 pub struct PrivateServiceDetails {
4427 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4428 pub autoscaling: ::std::option::Option<PrivateServiceDetailsAutoscaling>,
4429 #[serde(
4430 rename = "buildPlan",
4431 default,
4432 skip_serializing_if = "::std::option::Option::is_none"
4433 )]
4434 pub build_plan: ::std::option::Option<BuildPlan>,
4435 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4436 pub disk: ::std::option::Option<PrivateServiceDetailsDisk>,
4437 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4438 pub env: ::std::option::Option<ServiceEnv>,
4439 #[serde(
4440 rename = "envSpecificDetails",
4441 default,
4442 skip_serializing_if = "::std::option::Option::is_none"
4443 )]
4444 pub env_specific_details: ::std::option::Option<EnvSpecificDetails>,
4445 #[serde(
4446 rename = "maxShutdownDelaySeconds",
4447 default,
4448 skip_serializing_if = "::std::option::Option::is_none"
4449 )]
4450 pub max_shutdown_delay_seconds: ::std::option::Option<MaxShutdownDelaySeconds>,
4451 ///For a *manually* scaled service, this is the number of instances the
4452 /// service is scaled to. DOES NOT indicate the number of running
4453 /// instances for an *autoscaled* service.
4454 #[serde(
4455 rename = "numInstances",
4456 default,
4457 skip_serializing_if = "::std::option::Option::is_none"
4458 )]
4459 pub num_instances: ::std::option::Option<i64>,
4460 #[serde(
4461 rename = "openPorts",
4462 default,
4463 skip_serializing_if = "::std::vec::Vec::is_empty"
4464 )]
4465 pub open_ports: ::std::vec::Vec<ServerPort>,
4466 #[serde(
4467 rename = "parentServer",
4468 default,
4469 skip_serializing_if = "::std::option::Option::is_none"
4470 )]
4471 pub parent_server: ::std::option::Option<Resource>,
4472 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4473 pub plan: ::std::option::Option<Plan>,
4474 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4475 pub previews: ::std::option::Option<Previews>,
4476 #[serde(
4477 rename = "pullRequestPreviewsEnabled",
4478 default,
4479 skip_serializing_if = "::std::option::Option::is_none"
4480 )]
4481 pub pull_request_previews_enabled: ::std::option::Option<PullRequestPreviewsEnabled>,
4482 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4483 pub region: ::std::option::Option<Region>,
4484 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4485 pub runtime: ::std::option::Option<ServiceRuntime>,
4486 #[serde(
4487 rename = "sshAddress",
4488 default,
4489 skip_serializing_if = "::std::option::Option::is_none"
4490 )]
4491 pub ssh_address: ::std::option::Option<SshAddress>,
4492 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4493 pub url: ::std::option::Option<::std::string::String>,
4494 }
4495
4496 impl ::std::default::Default for PrivateServiceDetails {
4497 fn default() -> Self {
4498 Self {
4499 autoscaling: Default::default(),
4500 build_plan: Default::default(),
4501 disk: Default::default(),
4502 env: Default::default(),
4503 env_specific_details: Default::default(),
4504 max_shutdown_delay_seconds: Default::default(),
4505 num_instances: Default::default(),
4506 open_ports: Default::default(),
4507 parent_server: Default::default(),
4508 plan: Default::default(),
4509 previews: Default::default(),
4510 pull_request_previews_enabled: Default::default(),
4511 region: Default::default(),
4512 runtime: Default::default(),
4513 ssh_address: Default::default(),
4514 url: Default::default(),
4515 }
4516 }
4517 }
4518
4519 ///`PrivateServiceDetailsAutoscaling`
4520 ///
4521 /// <details><summary>JSON schema</summary>
4522 ///
4523 /// ```json
4524 ///{
4525 /// "type": "object",
4526 /// "properties": {
4527 /// "criteria": {
4528 /// "type": "object",
4529 /// "properties": {
4530 /// "cpu": {
4531 /// "type": "object",
4532 /// "properties": {
4533 /// "enabled": {
4534 /// "default": false,
4535 /// "type": "boolean"
4536 /// },
4537 /// "percentage": {
4538 /// "description": "Determines when your service will be
4539 /// scaled. If the average resource utilization is significantly above/below
4540 /// the target, we will increase/decrease the number of instances.\n",
4541 /// "type": "integer"
4542 /// }
4543 /// }
4544 /// },
4545 /// "memory": {
4546 /// "type": "object",
4547 /// "properties": {
4548 /// "enabled": {
4549 /// "default": false,
4550 /// "type": "boolean"
4551 /// },
4552 /// "percentage": {
4553 /// "description": "Determines when your service will be
4554 /// scaled. If the average resource utilization is significantly above/below
4555 /// the target, we will increase/decrease the number of instances.\n",
4556 /// "type": "integer"
4557 /// }
4558 /// }
4559 /// }
4560 /// }
4561 /// },
4562 /// "enabled": {
4563 /// "default": false,
4564 /// "type": "boolean"
4565 /// },
4566 /// "max": {
4567 /// "description": "The maximum number of instances for the service",
4568 /// "type": "integer"
4569 /// },
4570 /// "min": {
4571 /// "description": "The minimum number of instances for the service",
4572 /// "type": "integer"
4573 /// }
4574 /// }
4575 ///}
4576 /// ```
4577 /// </details>
4578 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4579 pub struct PrivateServiceDetailsAutoscaling {
4580 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4581 pub criteria: ::std::option::Option<PrivateServiceDetailsAutoscalingCriteria>,
4582 #[serde(default)]
4583 pub enabled: bool,
4584 ///The maximum number of instances for the service
4585 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4586 pub max: ::std::option::Option<i64>,
4587 ///The minimum number of instances for the service
4588 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4589 pub min: ::std::option::Option<i64>,
4590 }
4591
4592 impl ::std::default::Default for PrivateServiceDetailsAutoscaling {
4593 fn default() -> Self {
4594 Self {
4595 criteria: Default::default(),
4596 enabled: Default::default(),
4597 max: Default::default(),
4598 min: Default::default(),
4599 }
4600 }
4601 }
4602
4603 ///`PrivateServiceDetailsAutoscalingCriteria`
4604 ///
4605 /// <details><summary>JSON schema</summary>
4606 ///
4607 /// ```json
4608 ///{
4609 /// "type": "object",
4610 /// "properties": {
4611 /// "cpu": {
4612 /// "type": "object",
4613 /// "properties": {
4614 /// "enabled": {
4615 /// "default": false,
4616 /// "type": "boolean"
4617 /// },
4618 /// "percentage": {
4619 /// "description": "Determines when your service will be scaled. If
4620 /// the average resource utilization is significantly above/below the
4621 /// target, we will increase/decrease the number of instances.\n",
4622 /// "type": "integer"
4623 /// }
4624 /// }
4625 /// },
4626 /// "memory": {
4627 /// "type": "object",
4628 /// "properties": {
4629 /// "enabled": {
4630 /// "default": false,
4631 /// "type": "boolean"
4632 /// },
4633 /// "percentage": {
4634 /// "description": "Determines when your service will be scaled. If
4635 /// the average resource utilization is significantly above/below the
4636 /// target, we will increase/decrease the number of instances.\n",
4637 /// "type": "integer"
4638 /// }
4639 /// }
4640 /// }
4641 /// }
4642 ///}
4643 /// ```
4644 /// </details>
4645 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4646 pub struct PrivateServiceDetailsAutoscalingCriteria {
4647 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4648 pub cpu: ::std::option::Option<PrivateServiceDetailsAutoscalingCriteriaCpu>,
4649 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4650 pub memory: ::std::option::Option<PrivateServiceDetailsAutoscalingCriteriaMemory>,
4651 }
4652
4653 impl ::std::default::Default for PrivateServiceDetailsAutoscalingCriteria {
4654 fn default() -> Self {
4655 Self {
4656 cpu: Default::default(),
4657 memory: Default::default(),
4658 }
4659 }
4660 }
4661
4662 ///`PrivateServiceDetailsAutoscalingCriteriaCpu`
4663 ///
4664 /// <details><summary>JSON schema</summary>
4665 ///
4666 /// ```json
4667 ///{
4668 /// "type": "object",
4669 /// "properties": {
4670 /// "enabled": {
4671 /// "default": false,
4672 /// "type": "boolean"
4673 /// },
4674 /// "percentage": {
4675 /// "description": "Determines when your service will be scaled. If the
4676 /// average resource utilization is significantly above/below the target, we
4677 /// will increase/decrease the number of instances.\n",
4678 /// "type": "integer"
4679 /// }
4680 /// }
4681 ///}
4682 /// ```
4683 /// </details>
4684 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4685 pub struct PrivateServiceDetailsAutoscalingCriteriaCpu {
4686 #[serde(default)]
4687 pub enabled: bool,
4688 ///Determines when your service will be scaled. If the average resource
4689 /// utilization is significantly above/below the target, we will
4690 /// increase/decrease the number of instances.
4691 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4692 pub percentage: ::std::option::Option<i64>,
4693 }
4694
4695 impl ::std::default::Default for PrivateServiceDetailsAutoscalingCriteriaCpu {
4696 fn default() -> Self {
4697 Self {
4698 enabled: Default::default(),
4699 percentage: Default::default(),
4700 }
4701 }
4702 }
4703
4704 ///`PrivateServiceDetailsAutoscalingCriteriaMemory`
4705 ///
4706 /// <details><summary>JSON schema</summary>
4707 ///
4708 /// ```json
4709 ///{
4710 /// "type": "object",
4711 /// "properties": {
4712 /// "enabled": {
4713 /// "default": false,
4714 /// "type": "boolean"
4715 /// },
4716 /// "percentage": {
4717 /// "description": "Determines when your service will be scaled. If the
4718 /// average resource utilization is significantly above/below the target, we
4719 /// will increase/decrease the number of instances.\n",
4720 /// "type": "integer"
4721 /// }
4722 /// }
4723 ///}
4724 /// ```
4725 /// </details>
4726 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4727 pub struct PrivateServiceDetailsAutoscalingCriteriaMemory {
4728 #[serde(default)]
4729 pub enabled: bool,
4730 ///Determines when your service will be scaled. If the average resource
4731 /// utilization is significantly above/below the target, we will
4732 /// increase/decrease the number of instances.
4733 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4734 pub percentage: ::std::option::Option<i64>,
4735 }
4736
4737 impl ::std::default::Default for PrivateServiceDetailsAutoscalingCriteriaMemory {
4738 fn default() -> Self {
4739 Self {
4740 enabled: Default::default(),
4741 percentage: Default::default(),
4742 }
4743 }
4744 }
4745
4746 ///`PrivateServiceDetailsDisk`
4747 ///
4748 /// <details><summary>JSON schema</summary>
4749 ///
4750 /// ```json
4751 ///{
4752 /// "type": "object",
4753 /// "properties": {
4754 /// "id": {
4755 /// "examples": [
4756 /// "dsk-cph1rs3idesc73a2b2mg"
4757 /// ],
4758 /// "type": "string",
4759 /// "pattern": "^dsk-[0-9a-z]{20}$"
4760 /// },
4761 /// "mountPath": {
4762 /// "type": "string"
4763 /// },
4764 /// "name": {
4765 /// "type": "string"
4766 /// },
4767 /// "sizeGB": {
4768 /// "type": "integer"
4769 /// }
4770 /// }
4771 ///}
4772 /// ```
4773 /// </details>
4774 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4775 pub struct PrivateServiceDetailsDisk {
4776 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4777 pub id: ::std::option::Option<PrivateServiceDetailsDiskId>,
4778 #[serde(
4779 rename = "mountPath",
4780 default,
4781 skip_serializing_if = "::std::option::Option::is_none"
4782 )]
4783 pub mount_path: ::std::option::Option<::std::string::String>,
4784 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4785 pub name: ::std::option::Option<::std::string::String>,
4786 #[serde(
4787 rename = "sizeGB",
4788 default,
4789 skip_serializing_if = "::std::option::Option::is_none"
4790 )]
4791 pub size_gb: ::std::option::Option<i64>,
4792 }
4793
4794 impl ::std::default::Default for PrivateServiceDetailsDisk {
4795 fn default() -> Self {
4796 Self {
4797 id: Default::default(),
4798 mount_path: Default::default(),
4799 name: Default::default(),
4800 size_gb: Default::default(),
4801 }
4802 }
4803 }
4804
4805 ///`PrivateServiceDetailsDiskId`
4806 ///
4807 /// <details><summary>JSON schema</summary>
4808 ///
4809 /// ```json
4810 ///{
4811 /// "examples": [
4812 /// "dsk-cph1rs3idesc73a2b2mg"
4813 /// ],
4814 /// "type": "string",
4815 /// "pattern": "^dsk-[0-9a-z]{20}$"
4816 ///}
4817 /// ```
4818 /// </details>
4819 #[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
4820 #[serde(transparent)]
4821 pub struct PrivateServiceDetailsDiskId(::std::string::String);
4822 impl ::std::ops::Deref for PrivateServiceDetailsDiskId {
4823 type Target = ::std::string::String;
4824 fn deref(&self) -> &::std::string::String {
4825 &self.0
4826 }
4827 }
4828
4829 impl ::std::convert::From<PrivateServiceDetailsDiskId> for ::std::string::String {
4830 fn from(value: PrivateServiceDetailsDiskId) -> Self {
4831 value.0
4832 }
4833 }
4834
4835 impl ::std::str::FromStr for PrivateServiceDetailsDiskId {
4836 type Err = self::error::ConversionError;
4837 fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4838 static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
4839 ::std::sync::LazyLock::new(|| ::regress::Regex::new("^dsk-[0-9a-z]{20}$").unwrap());
4840 if PATTERN.find(value).is_none() {
4841 return Err("doesn't match pattern \"^dsk-[0-9a-z]{20}$\"".into());
4842 }
4843 Ok(Self(value.to_string()))
4844 }
4845 }
4846
4847 impl ::std::convert::TryFrom<&str> for PrivateServiceDetailsDiskId {
4848 type Error = self::error::ConversionError;
4849 fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
4850 value.parse()
4851 }
4852 }
4853
4854 impl ::std::convert::TryFrom<&::std::string::String> for PrivateServiceDetailsDiskId {
4855 type Error = self::error::ConversionError;
4856 fn try_from(
4857 value: &::std::string::String,
4858 ) -> ::std::result::Result<Self, self::error::ConversionError> {
4859 value.parse()
4860 }
4861 }
4862
4863 impl ::std::convert::TryFrom<::std::string::String> for PrivateServiceDetailsDiskId {
4864 type Error = self::error::ConversionError;
4865 fn try_from(
4866 value: ::std::string::String,
4867 ) -> ::std::result::Result<Self, self::error::ConversionError> {
4868 value.parse()
4869 }
4870 }
4871
4872 impl<'de> ::serde::Deserialize<'de> for PrivateServiceDetailsDiskId {
4873 fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
4874 where
4875 D: ::serde::Deserializer<'de>,
4876 {
4877 ::std::string::String::deserialize(deserializer)?
4878 .parse()
4879 .map_err(|e: self::error::ConversionError| {
4880 <D::Error as ::serde::de::Error>::custom(e.to_string())
4881 })
4882 }
4883 }
4884
4885 ///`PrivateServiceDetailsPost`
4886 ///
4887 /// <details><summary>JSON schema</summary>
4888 ///
4889 /// ```json
4890 ///{
4891 /// "type": "object",
4892 /// "properties": {
4893 /// "autoscaling": {
4894 /// "type": "object",
4895 /// "properties": {
4896 /// "criteria": {
4897 /// "type": "object",
4898 /// "properties": {
4899 /// "cpu": {
4900 /// "type": "object",
4901 /// "properties": {
4902 /// "enabled": {
4903 /// "default": false,
4904 /// "type": "boolean"
4905 /// },
4906 /// "percentage": {
4907 /// "description": "Determines when your service will be
4908 /// scaled. If the average resource utilization is significantly above/below
4909 /// the target, we will increase/decrease the number of instances.\n",
4910 /// "type": "integer"
4911 /// }
4912 /// }
4913 /// },
4914 /// "memory": {
4915 /// "type": "object",
4916 /// "properties": {
4917 /// "enabled": {
4918 /// "default": false,
4919 /// "type": "boolean"
4920 /// },
4921 /// "percentage": {
4922 /// "description": "Determines when your service will be
4923 /// scaled. If the average resource utilization is significantly above/below
4924 /// the target, we will increase/decrease the number of instances.\n",
4925 /// "type": "integer"
4926 /// }
4927 /// }
4928 /// }
4929 /// }
4930 /// },
4931 /// "enabled": {
4932 /// "default": false,
4933 /// "type": "boolean"
4934 /// },
4935 /// "max": {
4936 /// "description": "The maximum number of instances for the
4937 /// service",
4938 /// "type": "integer"
4939 /// },
4940 /// "min": {
4941 /// "description": "The minimum number of instances for the
4942 /// service",
4943 /// "type": "integer"
4944 /// }
4945 /// }
4946 /// },
4947 /// "disk": {
4948 /// "$ref": "#/components/schemas/serviceDisk"
4949 /// },
4950 /// "env": {
4951 /// "$ref": "#/components/schemas/serviceEnv"
4952 /// },
4953 /// "envSpecificDetails": {
4954 /// "$ref": "#/components/schemas/envSpecificDetailsPOST"
4955 /// },
4956 /// "maxShutdownDelaySeconds": {
4957 /// "$ref": "#/components/schemas/maxShutdownDelaySeconds"
4958 /// },
4959 /// "numInstances": {
4960 /// "description": "Defaults to 1",
4961 /// "default": 1,
4962 /// "type": "integer",
4963 /// "minimum": 1.0
4964 /// },
4965 /// "plan": {
4966 /// "$ref": "#/components/schemas/paidPlan"
4967 /// },
4968 /// "preDeployCommand": {
4969 /// "type": "string"
4970 /// },
4971 /// "previews": {
4972 /// "$ref": "#/components/schemas/previews"
4973 /// },
4974 /// "pullRequestPreviewsEnabled": {
4975 /// "$ref": "#/components/schemas/pullRequestPreviewsEnabled"
4976 /// },
4977 /// "region": {
4978 /// "$ref": "#/components/schemas/region"
4979 /// },
4980 /// "runtime": {
4981 /// "$ref": "#/components/schemas/serviceRuntime"
4982 /// }
4983 /// }
4984 ///}
4985 /// ```
4986 /// </details>
4987 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
4988 pub struct PrivateServiceDetailsPost {
4989 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4990 pub autoscaling: ::std::option::Option<PrivateServiceDetailsPostAutoscaling>,
4991 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4992 pub disk: ::std::option::Option<ServiceDisk>,
4993 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
4994 pub env: ::std::option::Option<ServiceEnv>,
4995 #[serde(
4996 rename = "envSpecificDetails",
4997 default,
4998 skip_serializing_if = "::std::option::Option::is_none"
4999 )]
5000 pub env_specific_details: ::std::option::Option<EnvSpecificDetailsPost>,
5001 #[serde(
5002 rename = "maxShutdownDelaySeconds",
5003 default,
5004 skip_serializing_if = "::std::option::Option::is_none"
5005 )]
5006 pub max_shutdown_delay_seconds: ::std::option::Option<MaxShutdownDelaySeconds>,
5007 ///Defaults to 1
5008 #[serde(
5009 rename = "numInstances",
5010 default = "defaults::default_nzu64::<::std::num::NonZeroU64, 1>"
5011 )]
5012 pub num_instances: ::std::num::NonZeroU64,
5013 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5014 pub plan: ::std::option::Option<PaidPlan>,
5015 #[serde(
5016 rename = "preDeployCommand",
5017 default,
5018 skip_serializing_if = "::std::option::Option::is_none"
5019 )]
5020 pub pre_deploy_command: ::std::option::Option<::std::string::String>,
5021 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5022 pub previews: ::std::option::Option<Previews>,
5023 #[serde(
5024 rename = "pullRequestPreviewsEnabled",
5025 default,
5026 skip_serializing_if = "::std::option::Option::is_none"
5027 )]
5028 pub pull_request_previews_enabled: ::std::option::Option<PullRequestPreviewsEnabled>,
5029 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5030 pub region: ::std::option::Option<Region>,
5031 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5032 pub runtime: ::std::option::Option<ServiceRuntime>,
5033 }
5034
5035 impl ::std::default::Default for PrivateServiceDetailsPost {
5036 fn default() -> Self {
5037 Self {
5038 autoscaling: Default::default(),
5039 disk: Default::default(),
5040 env: Default::default(),
5041 env_specific_details: Default::default(),
5042 max_shutdown_delay_seconds: Default::default(),
5043 num_instances: defaults::default_nzu64::<::std::num::NonZeroU64, 1>(),
5044 plan: Default::default(),
5045 pre_deploy_command: Default::default(),
5046 previews: Default::default(),
5047 pull_request_previews_enabled: Default::default(),
5048 region: Default::default(),
5049 runtime: Default::default(),
5050 }
5051 }
5052 }
5053
5054 ///`PrivateServiceDetailsPostAutoscaling`
5055 ///
5056 /// <details><summary>JSON schema</summary>
5057 ///
5058 /// ```json
5059 ///{
5060 /// "type": "object",
5061 /// "properties": {
5062 /// "criteria": {
5063 /// "type": "object",
5064 /// "properties": {
5065 /// "cpu": {
5066 /// "type": "object",
5067 /// "properties": {
5068 /// "enabled": {
5069 /// "default": false,
5070 /// "type": "boolean"
5071 /// },
5072 /// "percentage": {
5073 /// "description": "Determines when your service will be
5074 /// scaled. If the average resource utilization is significantly above/below
5075 /// the target, we will increase/decrease the number of instances.\n",
5076 /// "type": "integer"
5077 /// }
5078 /// }
5079 /// },
5080 /// "memory": {
5081 /// "type": "object",
5082 /// "properties": {
5083 /// "enabled": {
5084 /// "default": false,
5085 /// "type": "boolean"
5086 /// },
5087 /// "percentage": {
5088 /// "description": "Determines when your service will be
5089 /// scaled. If the average resource utilization is significantly above/below
5090 /// the target, we will increase/decrease the number of instances.\n",
5091 /// "type": "integer"
5092 /// }
5093 /// }
5094 /// }
5095 /// }
5096 /// },
5097 /// "enabled": {
5098 /// "default": false,
5099 /// "type": "boolean"
5100 /// },
5101 /// "max": {
5102 /// "description": "The maximum number of instances for the service",
5103 /// "type": "integer"
5104 /// },
5105 /// "min": {
5106 /// "description": "The minimum number of instances for the service",
5107 /// "type": "integer"
5108 /// }
5109 /// }
5110 ///}
5111 /// ```
5112 /// </details>
5113 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5114 pub struct PrivateServiceDetailsPostAutoscaling {
5115 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5116 pub criteria: ::std::option::Option<PrivateServiceDetailsPostAutoscalingCriteria>,
5117 #[serde(default)]
5118 pub enabled: bool,
5119 ///The maximum number of instances for the service
5120 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5121 pub max: ::std::option::Option<i64>,
5122 ///The minimum number of instances for the service
5123 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5124 pub min: ::std::option::Option<i64>,
5125 }
5126
5127 impl ::std::default::Default for PrivateServiceDetailsPostAutoscaling {
5128 fn default() -> Self {
5129 Self {
5130 criteria: Default::default(),
5131 enabled: Default::default(),
5132 max: Default::default(),
5133 min: Default::default(),
5134 }
5135 }
5136 }
5137
5138 ///`PrivateServiceDetailsPostAutoscalingCriteria`
5139 ///
5140 /// <details><summary>JSON schema</summary>
5141 ///
5142 /// ```json
5143 ///{
5144 /// "type": "object",
5145 /// "properties": {
5146 /// "cpu": {
5147 /// "type": "object",
5148 /// "properties": {
5149 /// "enabled": {
5150 /// "default": false,
5151 /// "type": "boolean"
5152 /// },
5153 /// "percentage": {
5154 /// "description": "Determines when your service will be scaled. If
5155 /// the average resource utilization is significantly above/below the
5156 /// target, we will increase/decrease the number of instances.\n",
5157 /// "type": "integer"
5158 /// }
5159 /// }
5160 /// },
5161 /// "memory": {
5162 /// "type": "object",
5163 /// "properties": {
5164 /// "enabled": {
5165 /// "default": false,
5166 /// "type": "boolean"
5167 /// },
5168 /// "percentage": {
5169 /// "description": "Determines when your service will be scaled. If
5170 /// the average resource utilization is significantly above/below the
5171 /// target, we will increase/decrease the number of instances.\n",
5172 /// "type": "integer"
5173 /// }
5174 /// }
5175 /// }
5176 /// }
5177 ///}
5178 /// ```
5179 /// </details>
5180 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5181 pub struct PrivateServiceDetailsPostAutoscalingCriteria {
5182 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5183 pub cpu: ::std::option::Option<PrivateServiceDetailsPostAutoscalingCriteriaCpu>,
5184 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5185 pub memory: ::std::option::Option<PrivateServiceDetailsPostAutoscalingCriteriaMemory>,
5186 }
5187
5188 impl ::std::default::Default for PrivateServiceDetailsPostAutoscalingCriteria {
5189 fn default() -> Self {
5190 Self {
5191 cpu: Default::default(),
5192 memory: Default::default(),
5193 }
5194 }
5195 }
5196
5197 ///`PrivateServiceDetailsPostAutoscalingCriteriaCpu`
5198 ///
5199 /// <details><summary>JSON schema</summary>
5200 ///
5201 /// ```json
5202 ///{
5203 /// "type": "object",
5204 /// "properties": {
5205 /// "enabled": {
5206 /// "default": false,
5207 /// "type": "boolean"
5208 /// },
5209 /// "percentage": {
5210 /// "description": "Determines when your service will be scaled. If the
5211 /// average resource utilization is significantly above/below the target, we
5212 /// will increase/decrease the number of instances.\n",
5213 /// "type": "integer"
5214 /// }
5215 /// }
5216 ///}
5217 /// ```
5218 /// </details>
5219 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5220 pub struct PrivateServiceDetailsPostAutoscalingCriteriaCpu {
5221 #[serde(default)]
5222 pub enabled: bool,
5223 ///Determines when your service will be scaled. If the average resource
5224 /// utilization is significantly above/below the target, we will
5225 /// increase/decrease the number of instances.
5226 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5227 pub percentage: ::std::option::Option<i64>,
5228 }
5229
5230 impl ::std::default::Default for PrivateServiceDetailsPostAutoscalingCriteriaCpu {
5231 fn default() -> Self {
5232 Self {
5233 enabled: Default::default(),
5234 percentage: Default::default(),
5235 }
5236 }
5237 }
5238
5239 ///`PrivateServiceDetailsPostAutoscalingCriteriaMemory`
5240 ///
5241 /// <details><summary>JSON schema</summary>
5242 ///
5243 /// ```json
5244 ///{
5245 /// "type": "object",
5246 /// "properties": {
5247 /// "enabled": {
5248 /// "default": false,
5249 /// "type": "boolean"
5250 /// },
5251 /// "percentage": {
5252 /// "description": "Determines when your service will be scaled. If the
5253 /// average resource utilization is significantly above/below the target, we
5254 /// will increase/decrease the number of instances.\n",
5255 /// "type": "integer"
5256 /// }
5257 /// }
5258 ///}
5259 /// ```
5260 /// </details>
5261 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5262 pub struct PrivateServiceDetailsPostAutoscalingCriteriaMemory {
5263 #[serde(default)]
5264 pub enabled: bool,
5265 ///Determines when your service will be scaled. If the average resource
5266 /// utilization is significantly above/below the target, we will
5267 /// increase/decrease the number of instances.
5268 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5269 pub percentage: ::std::option::Option<i64>,
5270 }
5271
5272 impl ::std::default::Default for PrivateServiceDetailsPostAutoscalingCriteriaMemory {
5273 fn default() -> Self {
5274 Self {
5275 enabled: Default::default(),
5276 percentage: Default::default(),
5277 }
5278 }
5279 }
5280
5281 ///This field has been deprecated. previews.generation should be used in
5282 /// its place.
5283 ///
5284 /// <details><summary>JSON schema</summary>
5285 ///
5286 /// ```json
5287 ///{
5288 /// "description": "This field has been deprecated. previews.generation
5289 /// should be used in its place.",
5290 /// "default": "no",
5291 /// "deprecated": true,
5292 /// "type": "string"
5293 ///}
5294 /// ```
5295 /// </details>
5296 #[derive(
5297 :: serde :: Deserialize,
5298 :: serde :: Serialize,
5299 Clone,
5300 Debug,
5301 Eq,
5302 Hash,
5303 Ord,
5304 PartialEq,
5305 PartialOrd,
5306 )]
5307 #[serde(transparent)]
5308 pub struct PullRequestPreviewsEnabled(pub ::std::string::String);
5309 impl ::std::ops::Deref for PullRequestPreviewsEnabled {
5310 type Target = ::std::string::String;
5311 fn deref(&self) -> &::std::string::String {
5312 &self.0
5313 }
5314 }
5315
5316 impl ::std::convert::From<PullRequestPreviewsEnabled> for ::std::string::String {
5317 fn from(value: PullRequestPreviewsEnabled) -> Self {
5318 value.0
5319 }
5320 }
5321
5322 impl ::std::convert::From<::std::string::String> for PullRequestPreviewsEnabled {
5323 fn from(value: ::std::string::String) -> Self {
5324 Self(value)
5325 }
5326 }
5327
5328 impl ::std::str::FromStr for PullRequestPreviewsEnabled {
5329 type Err = ::std::convert::Infallible;
5330 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
5331 Ok(Self(value.to_string()))
5332 }
5333 }
5334
5335 impl ::std::fmt::Display for PullRequestPreviewsEnabled {
5336 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5337 self.0.fmt(f)
5338 }
5339 }
5340
5341 ///`ReadReplica`
5342 ///
5343 /// <details><summary>JSON schema</summary>
5344 ///
5345 /// ```json
5346 ///{
5347 /// "type": "object",
5348 /// "properties": {
5349 /// "id": {
5350 /// "description": "The replica instance identifier.",
5351 /// "type": "string"
5352 /// },
5353 /// "name": {
5354 /// "description": "The display name of the replica instance.",
5355 /// "type": "string"
5356 /// },
5357 /// "parameterOverrides": {
5358 /// "$ref": "#/components/schemas/postgresParameterOverrides"
5359 /// }
5360 /// }
5361 ///}
5362 /// ```
5363 /// </details>
5364 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5365 pub struct ReadReplica {
5366 ///The replica instance identifier.
5367 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5368 pub id: ::std::option::Option<::std::string::String>,
5369 ///The display name of the replica instance.
5370 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5371 pub name: ::std::option::Option<::std::string::String>,
5372 #[serde(
5373 rename = "parameterOverrides",
5374 default,
5375 skip_serializing_if = "::std::option::Option::is_none"
5376 )]
5377 pub parameter_overrides: ::std::option::Option<PostgresParameterOverrides>,
5378 }
5379
5380 impl ::std::default::Default for ReadReplica {
5381 fn default() -> Self {
5382 Self {
5383 id: Default::default(),
5384 name: Default::default(),
5385 parameter_overrides: Default::default(),
5386 }
5387 }
5388 }
5389
5390 ///`ReadReplicaInput`
5391 ///
5392 /// <details><summary>JSON schema</summary>
5393 ///
5394 /// ```json
5395 ///{
5396 /// "type": "object",
5397 /// "properties": {
5398 /// "name": {
5399 /// "description": "The display name of the replica instance.",
5400 /// "type": "string"
5401 /// },
5402 /// "parameterOverrides": {
5403 /// "$ref": "#/components/schemas/postgresParameterOverrides"
5404 /// }
5405 /// }
5406 ///}
5407 /// ```
5408 /// </details>
5409 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5410 pub struct ReadReplicaInput {
5411 ///The display name of the replica instance.
5412 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5413 pub name: ::std::option::Option<::std::string::String>,
5414 #[serde(
5415 rename = "parameterOverrides",
5416 default,
5417 skip_serializing_if = "::std::option::Option::is_none"
5418 )]
5419 pub parameter_overrides: ::std::option::Option<PostgresParameterOverrides>,
5420 }
5421
5422 impl ::std::default::Default for ReadReplicaInput {
5423 fn default() -> Self {
5424 Self {
5425 name: Default::default(),
5426 parameter_overrides: Default::default(),
5427 }
5428 }
5429 }
5430
5431 ///`ReadReplicas`
5432 ///
5433 /// <details><summary>JSON schema</summary>
5434 ///
5435 /// ```json
5436 ///{
5437 /// "type": "array",
5438 /// "items": {
5439 /// "$ref": "#/components/schemas/readReplica"
5440 /// }
5441 ///}
5442 /// ```
5443 /// </details>
5444 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5445 #[serde(transparent)]
5446 pub struct ReadReplicas(pub ::std::vec::Vec<ReadReplica>);
5447 impl ::std::ops::Deref for ReadReplicas {
5448 type Target = ::std::vec::Vec<ReadReplica>;
5449 fn deref(&self) -> &::std::vec::Vec<ReadReplica> {
5450 &self.0
5451 }
5452 }
5453
5454 impl ::std::convert::From<ReadReplicas> for ::std::vec::Vec<ReadReplica> {
5455 fn from(value: ReadReplicas) -> Self {
5456 value.0
5457 }
5458 }
5459
5460 impl ::std::convert::From<::std::vec::Vec<ReadReplica>> for ReadReplicas {
5461 fn from(value: ::std::vec::Vec<ReadReplica>) -> Self {
5462 Self(value)
5463 }
5464 }
5465
5466 ///`ReadReplicasInput`
5467 ///
5468 /// <details><summary>JSON schema</summary>
5469 ///
5470 /// ```json
5471 ///{
5472 /// "type": "array",
5473 /// "items": {
5474 /// "$ref": "#/components/schemas/readReplicaInput"
5475 /// }
5476 ///}
5477 /// ```
5478 /// </details>
5479 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5480 #[serde(transparent)]
5481 pub struct ReadReplicasInput(pub ::std::vec::Vec<ReadReplicaInput>);
5482 impl ::std::ops::Deref for ReadReplicasInput {
5483 type Target = ::std::vec::Vec<ReadReplicaInput>;
5484 fn deref(&self) -> &::std::vec::Vec<ReadReplicaInput> {
5485 &self.0
5486 }
5487 }
5488
5489 impl ::std::convert::From<ReadReplicasInput> for ::std::vec::Vec<ReadReplicaInput> {
5490 fn from(value: ReadReplicasInput) -> Self {
5491 value.0
5492 }
5493 }
5494
5495 impl ::std::convert::From<::std::vec::Vec<ReadReplicaInput>> for ReadReplicasInput {
5496 fn from(value: ::std::vec::Vec<ReadReplicaInput>) -> Self {
5497 Self(value)
5498 }
5499 }
5500
5501 ///Defaults to "oregon"
5502 ///
5503 /// <details><summary>JSON schema</summary>
5504 ///
5505 /// ```json
5506 ///{
5507 /// "description": "Defaults to \"oregon\"",
5508 /// "default": "oregon",
5509 /// "type": "string"
5510 ///}
5511 /// ```
5512 /// </details>
5513 #[derive(
5514 :: serde :: Deserialize,
5515 :: serde :: Serialize,
5516 Clone,
5517 Debug,
5518 Eq,
5519 Hash,
5520 Ord,
5521 PartialEq,
5522 PartialOrd,
5523 )]
5524 #[serde(transparent)]
5525 pub struct Region(pub ::std::string::String);
5526 impl ::std::ops::Deref for Region {
5527 type Target = ::std::string::String;
5528 fn deref(&self) -> &::std::string::String {
5529 &self.0
5530 }
5531 }
5532
5533 impl ::std::convert::From<Region> for ::std::string::String {
5534 fn from(value: Region) -> Self {
5535 value.0
5536 }
5537 }
5538
5539 impl ::std::convert::From<::std::string::String> for Region {
5540 fn from(value: ::std::string::String) -> Self {
5541 Self(value)
5542 }
5543 }
5544
5545 impl ::std::str::FromStr for Region {
5546 type Err = ::std::convert::Infallible;
5547 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
5548 Ok(Self(value.to_string()))
5549 }
5550 }
5551
5552 impl ::std::fmt::Display for Region {
5553 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5554 self.0.fmt(f)
5555 }
5556 }
5557
5558 ///`RegistryCredential`
5559 ///
5560 /// <details><summary>JSON schema</summary>
5561 ///
5562 /// ```json
5563 ///{
5564 /// "type": "object",
5565 /// "properties": {
5566 /// "id": {
5567 /// "description": "Unique identifier for this credential",
5568 /// "type": "string"
5569 /// },
5570 /// "name": {
5571 /// "description": "Descriptive name for this credential",
5572 /// "type": "string"
5573 /// },
5574 /// "registry": {
5575 /// "$ref": "#/components/schemas/registryCredentialRegistry"
5576 /// },
5577 /// "updatedAt": {
5578 /// "description": "Last updated time for the credential",
5579 /// "type": "string",
5580 /// "format": "date-time"
5581 /// },
5582 /// "username": {
5583 /// "description": "The username associated with the credential",
5584 /// "type": "string"
5585 /// }
5586 /// }
5587 ///}
5588 /// ```
5589 /// </details>
5590 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5591 pub struct RegistryCredential {
5592 ///Unique identifier for this credential
5593 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5594 pub id: ::std::option::Option<::std::string::String>,
5595 ///Descriptive name for this credential
5596 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5597 pub name: ::std::option::Option<::std::string::String>,
5598 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5599 pub registry: ::std::option::Option<RegistryCredentialRegistry>,
5600 ///Last updated time for the credential
5601 #[serde(
5602 rename = "updatedAt",
5603 default,
5604 skip_serializing_if = "::std::option::Option::is_none"
5605 )]
5606 pub updated_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
5607 ///The username associated with the credential
5608 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5609 pub username: ::std::option::Option<::std::string::String>,
5610 }
5611
5612 impl ::std::default::Default for RegistryCredential {
5613 fn default() -> Self {
5614 Self {
5615 id: Default::default(),
5616 name: Default::default(),
5617 registry: Default::default(),
5618 updated_at: Default::default(),
5619 username: Default::default(),
5620 }
5621 }
5622 }
5623
5624 ///The registry to use this credential with
5625 ///
5626 /// <details><summary>JSON schema</summary>
5627 ///
5628 /// ```json
5629 ///{
5630 /// "description": "The registry to use this credential with",
5631 /// "type": "string"
5632 ///}
5633 /// ```
5634 /// </details>
5635 #[derive(
5636 :: serde :: Deserialize,
5637 :: serde :: Serialize,
5638 Clone,
5639 Debug,
5640 Eq,
5641 Hash,
5642 Ord,
5643 PartialEq,
5644 PartialOrd,
5645 )]
5646 #[serde(transparent)]
5647 pub struct RegistryCredentialRegistry(pub ::std::string::String);
5648 impl ::std::ops::Deref for RegistryCredentialRegistry {
5649 type Target = ::std::string::String;
5650 fn deref(&self) -> &::std::string::String {
5651 &self.0
5652 }
5653 }
5654
5655 impl ::std::convert::From<RegistryCredentialRegistry> for ::std::string::String {
5656 fn from(value: RegistryCredentialRegistry) -> Self {
5657 value.0
5658 }
5659 }
5660
5661 impl ::std::convert::From<::std::string::String> for RegistryCredentialRegistry {
5662 fn from(value: ::std::string::String) -> Self {
5663 Self(value)
5664 }
5665 }
5666
5667 impl ::std::str::FromStr for RegistryCredentialRegistry {
5668 type Err = ::std::convert::Infallible;
5669 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
5670 Ok(Self(value.to_string()))
5671 }
5672 }
5673
5674 impl ::std::fmt::Display for RegistryCredentialRegistry {
5675 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5676 self.0.fmt(f)
5677 }
5678 }
5679
5680 ///`RegistryCredentialSummary`
5681 ///
5682 /// <details><summary>JSON schema</summary>
5683 ///
5684 /// ```json
5685 ///{
5686 /// "type": "object",
5687 /// "properties": {
5688 /// "id": {
5689 /// "type": "string"
5690 /// },
5691 /// "name": {
5692 /// "type": "string"
5693 /// }
5694 /// }
5695 ///}
5696 /// ```
5697 /// </details>
5698 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5699 pub struct RegistryCredentialSummary {
5700 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5701 pub id: ::std::option::Option<::std::string::String>,
5702 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5703 pub name: ::std::option::Option<::std::string::String>,
5704 }
5705
5706 impl ::std::default::Default for RegistryCredentialSummary {
5707 fn default() -> Self {
5708 Self {
5709 id: Default::default(),
5710 name: Default::default(),
5711 }
5712 }
5713 }
5714
5715 ///Controls whether render.com subdomains are available for the service
5716 ///
5717 /// <details><summary>JSON schema</summary>
5718 ///
5719 /// ```json
5720 ///{
5721 /// "description": "Controls whether render.com subdomains are available
5722 /// for the service",
5723 /// "type": "string"
5724 ///}
5725 /// ```
5726 /// </details>
5727 #[derive(
5728 :: serde :: Deserialize,
5729 :: serde :: Serialize,
5730 Clone,
5731 Debug,
5732 Eq,
5733 Hash,
5734 Ord,
5735 PartialEq,
5736 PartialOrd,
5737 )]
5738 #[serde(transparent)]
5739 pub struct RenderSubdomainPolicy(pub ::std::string::String);
5740 impl ::std::ops::Deref for RenderSubdomainPolicy {
5741 type Target = ::std::string::String;
5742 fn deref(&self) -> &::std::string::String {
5743 &self.0
5744 }
5745 }
5746
5747 impl ::std::convert::From<RenderSubdomainPolicy> for ::std::string::String {
5748 fn from(value: RenderSubdomainPolicy) -> Self {
5749 value.0
5750 }
5751 }
5752
5753 impl ::std::convert::From<::std::string::String> for RenderSubdomainPolicy {
5754 fn from(value: ::std::string::String) -> Self {
5755 Self(value)
5756 }
5757 }
5758
5759 impl ::std::str::FromStr for RenderSubdomainPolicy {
5760 type Err = ::std::convert::Infallible;
5761 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
5762 Ok(Self(value.to_string()))
5763 }
5764 }
5765
5766 impl ::std::fmt::Display for RenderSubdomainPolicy {
5767 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5768 self.0.fmt(f)
5769 }
5770 }
5771
5772 ///`Resource`
5773 ///
5774 /// <details><summary>JSON schema</summary>
5775 ///
5776 /// ```json
5777 ///{
5778 /// "type": "object",
5779 /// "properties": {
5780 /// "id": {
5781 /// "type": "string"
5782 /// },
5783 /// "name": {
5784 /// "type": "string"
5785 /// }
5786 /// }
5787 ///}
5788 /// ```
5789 /// </details>
5790 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5791 pub struct Resource {
5792 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5793 pub id: ::std::option::Option<::std::string::String>,
5794 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5795 pub name: ::std::option::Option<::std::string::String>,
5796 }
5797
5798 impl ::std::default::Default for Resource {
5799 fn default() -> Self {
5800 Self {
5801 id: Default::default(),
5802 name: Default::default(),
5803 }
5804 }
5805 }
5806
5807 ///`Route`
5808 ///
5809 /// <details><summary>JSON schema</summary>
5810 ///
5811 /// ```json
5812 ///{
5813 /// "type": "object",
5814 /// "properties": {
5815 /// "destination": {
5816 /// "type": "string"
5817 /// },
5818 /// "id": {
5819 /// "type": "string"
5820 /// },
5821 /// "priority": {
5822 /// "description": "Redirect and Rewrite Rules are applied in priority
5823 /// order starting at 0",
5824 /// "type": "integer"
5825 /// },
5826 /// "source": {
5827 /// "type": "string"
5828 /// },
5829 /// "type": {
5830 /// "$ref": "#/components/schemas/routeType"
5831 /// }
5832 /// }
5833 ///}
5834 /// ```
5835 /// </details>
5836 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5837 pub struct Route {
5838 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5839 pub destination: ::std::option::Option<::std::string::String>,
5840 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5841 pub id: ::std::option::Option<::std::string::String>,
5842 ///Redirect and Rewrite Rules are applied in priority order starting at
5843 /// 0
5844 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5845 pub priority: ::std::option::Option<i64>,
5846 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5847 pub source: ::std::option::Option<::std::string::String>,
5848 #[serde(
5849 rename = "type",
5850 default,
5851 skip_serializing_if = "::std::option::Option::is_none"
5852 )]
5853 pub type_: ::std::option::Option<RouteType>,
5854 }
5855
5856 impl ::std::default::Default for Route {
5857 fn default() -> Self {
5858 Self {
5859 destination: Default::default(),
5860 id: Default::default(),
5861 priority: Default::default(),
5862 source: Default::default(),
5863 type_: Default::default(),
5864 }
5865 }
5866 }
5867
5868 ///`RoutePatch`
5869 ///
5870 /// <details><summary>JSON schema</summary>
5871 ///
5872 /// ```json
5873 ///{
5874 /// "type": "object",
5875 /// "properties": {
5876 /// "priority": {
5877 /// "description": "Redirect and Rewrite Rules are applied in priority
5878 /// order starting at 0. Moves this route to the specified priority and
5879 /// adjusts other route priorities accordingly.",
5880 /// "type": "integer",
5881 /// "x-go-type": "*int"
5882 /// }
5883 /// }
5884 ///}
5885 /// ```
5886 /// </details>
5887 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5888 pub struct RoutePatch {
5889 ///Redirect and Rewrite Rules are applied in priority order starting at
5890 /// 0. Moves this route to the specified priority and adjusts other
5891 /// route priorities accordingly.
5892 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5893 pub priority: ::std::option::Option<i64>,
5894 }
5895
5896 impl ::std::default::Default for RoutePatch {
5897 fn default() -> Self {
5898 Self {
5899 priority: Default::default(),
5900 }
5901 }
5902 }
5903
5904 ///`RoutePost`
5905 ///
5906 /// <details><summary>JSON schema</summary>
5907 ///
5908 /// ```json
5909 ///{
5910 /// "type": "object",
5911 /// "properties": {
5912 /// "destination": {
5913 /// "examples": [
5914 /// "/foo/:bar"
5915 /// ],
5916 /// "type": "string"
5917 /// },
5918 /// "priority": {
5919 /// "description": "Redirect and Rewrite Rules are applied in priority
5920 /// order starting at 0. Defaults to last in the priority list.",
5921 /// "type": "integer"
5922 /// },
5923 /// "source": {
5924 /// "examples": [
5925 /// "/:bar/foo"
5926 /// ],
5927 /// "type": "string"
5928 /// },
5929 /// "type": {
5930 /// "$ref": "#/components/schemas/routeType"
5931 /// }
5932 /// }
5933 ///}
5934 /// ```
5935 /// </details>
5936 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5937 pub struct RoutePost {
5938 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5939 pub destination: ::std::option::Option<::std::string::String>,
5940 ///Redirect and Rewrite Rules are applied in priority order starting at
5941 /// 0. Defaults to last in the priority list.
5942 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5943 pub priority: ::std::option::Option<i64>,
5944 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5945 pub source: ::std::option::Option<::std::string::String>,
5946 #[serde(
5947 rename = "type",
5948 default,
5949 skip_serializing_if = "::std::option::Option::is_none"
5950 )]
5951 pub type_: ::std::option::Option<RouteType>,
5952 }
5953
5954 impl ::std::default::Default for RoutePost {
5955 fn default() -> Self {
5956 Self {
5957 destination: Default::default(),
5958 priority: Default::default(),
5959 source: Default::default(),
5960 type_: Default::default(),
5961 }
5962 }
5963 }
5964
5965 ///`RoutePut`
5966 ///
5967 /// <details><summary>JSON schema</summary>
5968 ///
5969 /// ```json
5970 ///{
5971 /// "type": "object",
5972 /// "properties": {
5973 /// "destination": {
5974 /// "examples": [
5975 /// "/foo/:bar"
5976 /// ],
5977 /// "type": "string"
5978 /// },
5979 /// "source": {
5980 /// "examples": [
5981 /// "/:bar/foo"
5982 /// ],
5983 /// "type": "string"
5984 /// },
5985 /// "type": {
5986 /// "$ref": "#/components/schemas/routeType"
5987 /// }
5988 /// }
5989 ///}
5990 /// ```
5991 /// </details>
5992 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
5993 pub struct RoutePut {
5994 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5995 pub destination: ::std::option::Option<::std::string::String>,
5996 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
5997 pub source: ::std::option::Option<::std::string::String>,
5998 #[serde(
5999 rename = "type",
6000 default,
6001 skip_serializing_if = "::std::option::Option::is_none"
6002 )]
6003 pub type_: ::std::option::Option<RouteType>,
6004 }
6005
6006 impl ::std::default::Default for RoutePut {
6007 fn default() -> Self {
6008 Self {
6009 destination: Default::default(),
6010 source: Default::default(),
6011 type_: Default::default(),
6012 }
6013 }
6014 }
6015
6016 ///`RouteType`
6017 ///
6018 /// <details><summary>JSON schema</summary>
6019 ///
6020 /// ```json
6021 ///{
6022 /// "type": "string"
6023 ///}
6024 /// ```
6025 /// </details>
6026 #[derive(
6027 :: serde :: Deserialize,
6028 :: serde :: Serialize,
6029 Clone,
6030 Debug,
6031 Eq,
6032 Hash,
6033 Ord,
6034 PartialEq,
6035 PartialOrd,
6036 )]
6037 #[serde(transparent)]
6038 pub struct RouteType(pub ::std::string::String);
6039 impl ::std::ops::Deref for RouteType {
6040 type Target = ::std::string::String;
6041 fn deref(&self) -> &::std::string::String {
6042 &self.0
6043 }
6044 }
6045
6046 impl ::std::convert::From<RouteType> for ::std::string::String {
6047 fn from(value: RouteType) -> Self {
6048 value.0
6049 }
6050 }
6051
6052 impl ::std::convert::From<::std::string::String> for RouteType {
6053 fn from(value: ::std::string::String) -> Self {
6054 Self(value)
6055 }
6056 }
6057
6058 impl ::std::str::FromStr for RouteType {
6059 type Err = ::std::convert::Infallible;
6060 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
6061 Ok(Self(value.to_string()))
6062 }
6063 }
6064
6065 impl ::std::fmt::Display for RouteType {
6066 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6067 self.0.fmt(f)
6068 }
6069 }
6070
6071 ///`RouteWithCursor`
6072 ///
6073 /// <details><summary>JSON schema</summary>
6074 ///
6075 /// ```json
6076 ///{
6077 /// "type": "object",
6078 /// "properties": {
6079 /// "cursor": {
6080 /// "type": "string"
6081 /// },
6082 /// "route": {
6083 /// "$ref": "#/components/schemas/route"
6084 /// }
6085 /// }
6086 ///}
6087 /// ```
6088 /// </details>
6089 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6090 pub struct RouteWithCursor {
6091 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6092 pub cursor: ::std::option::Option<::std::string::String>,
6093 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6094 pub route: ::std::option::Option<Route>,
6095 }
6096
6097 impl ::std::default::Default for RouteWithCursor {
6098 fn default() -> Self {
6099 Self {
6100 cursor: Default::default(),
6101 route: Default::default(),
6102 }
6103 }
6104 }
6105
6106 ///`SecretFileInput`
6107 ///
6108 /// <details><summary>JSON schema</summary>
6109 ///
6110 /// ```json
6111 ///{
6112 /// "type": "object",
6113 /// "properties": {
6114 /// "content": {
6115 /// "type": "string"
6116 /// },
6117 /// "name": {
6118 /// "type": "string"
6119 /// }
6120 /// }
6121 ///}
6122 /// ```
6123 /// </details>
6124 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6125 pub struct SecretFileInput {
6126 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6127 pub content: ::std::option::Option<::std::string::String>,
6128 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6129 pub name: ::std::option::Option<::std::string::String>,
6130 }
6131
6132 impl ::std::default::Default for SecretFileInput {
6133 fn default() -> Self {
6134 Self {
6135 content: Default::default(),
6136 name: Default::default(),
6137 }
6138 }
6139 }
6140
6141 ///`ServerPort`
6142 ///
6143 /// <details><summary>JSON schema</summary>
6144 ///
6145 /// ```json
6146 ///{
6147 /// "type": "object",
6148 /// "properties": {
6149 /// "port": {
6150 /// "examples": [
6151 /// 10000
6152 /// ],
6153 /// "type": "integer"
6154 /// },
6155 /// "protocol": {
6156 /// "type": "string"
6157 /// }
6158 /// }
6159 ///}
6160 /// ```
6161 /// </details>
6162 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6163 pub struct ServerPort {
6164 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6165 pub port: ::std::option::Option<i64>,
6166 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6167 pub protocol: ::std::option::Option<::std::string::String>,
6168 }
6169
6170 impl ::std::default::Default for ServerPort {
6171 fn default() -> Self {
6172 Self {
6173 port: Default::default(),
6174 protocol: Default::default(),
6175 }
6176 }
6177 }
6178
6179 ///`Service`
6180 ///
6181 /// <details><summary>JSON schema</summary>
6182 ///
6183 /// ```json
6184 ///{
6185 /// "type": "object",
6186 /// "properties": {
6187 /// "autoDeploy": {
6188 /// "$ref": "#/components/schemas/autoDeploy"
6189 /// },
6190 /// "branch": {
6191 /// "type": "string"
6192 /// },
6193 /// "buildFilter": {
6194 /// "$ref": "#/components/schemas/buildFilter"
6195 /// },
6196 /// "createdAt": {
6197 /// "type": "string",
6198 /// "format": "date-time"
6199 /// },
6200 /// "dashboardUrl": {
6201 /// "description": "The URL to view the service in the Render
6202 /// Dashboard",
6203 /// "type": "string"
6204 /// },
6205 /// "environmentId": {
6206 /// "type": "string"
6207 /// },
6208 /// "id": {
6209 /// "type": "string"
6210 /// },
6211 /// "imagePath": {
6212 /// "type": "string"
6213 /// },
6214 /// "name": {
6215 /// "type": "string"
6216 /// },
6217 /// "notifyOnFail": {
6218 /// "$ref": "#/components/schemas/notifySetting"
6219 /// },
6220 /// "ownerId": {
6221 /// "type": "string"
6222 /// },
6223 /// "registryCredential": {
6224 /// "$ref": "#/components/schemas/registryCredentialSummary"
6225 /// },
6226 /// "repo": {
6227 /// "examples": [
6228 /// "https://github.com/render-examples/flask-hello-world"
6229 /// ],
6230 /// "type": "string"
6231 /// },
6232 /// "rootDir": {
6233 /// "type": "string"
6234 /// },
6235 /// "serviceDetails": {
6236 /// "oneOf": [
6237 /// {
6238 /// "$ref": "#/components/schemas/staticSiteDetails"
6239 /// },
6240 /// {
6241 /// "$ref": "#/components/schemas/webServiceDetails"
6242 /// },
6243 /// {
6244 /// "$ref": "#/components/schemas/privateServiceDetails"
6245 /// },
6246 /// {
6247 /// "$ref": "#/components/schemas/backgroundWorkerDetails"
6248 /// },
6249 /// {
6250 /// "$ref": "#/components/schemas/cronJobDetails"
6251 /// }
6252 /// ]
6253 /// },
6254 /// "slug": {
6255 /// "type": "string"
6256 /// },
6257 /// "suspended": {
6258 /// "type": "string"
6259 /// },
6260 /// "suspenders": {
6261 /// "type": "array",
6262 /// "items": {
6263 /// "$ref": "#/components/schemas/suspenderType"
6264 /// }
6265 /// },
6266 /// "type": {
6267 /// "$ref": "#/components/schemas/serviceType"
6268 /// },
6269 /// "updatedAt": {
6270 /// "type": "string",
6271 /// "format": "date-time"
6272 /// }
6273 /// }
6274 ///}
6275 /// ```
6276 /// </details>
6277 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6278 pub struct Service {
6279 #[serde(
6280 rename = "autoDeploy",
6281 default,
6282 skip_serializing_if = "::std::option::Option::is_none"
6283 )]
6284 pub auto_deploy: ::std::option::Option<AutoDeploy>,
6285 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6286 pub branch: ::std::option::Option<::std::string::String>,
6287 #[serde(
6288 rename = "buildFilter",
6289 default,
6290 skip_serializing_if = "::std::option::Option::is_none"
6291 )]
6292 pub build_filter: ::std::option::Option<BuildFilter>,
6293 #[serde(
6294 rename = "createdAt",
6295 default,
6296 skip_serializing_if = "::std::option::Option::is_none"
6297 )]
6298 pub created_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
6299 ///The URL to view the service in the Render Dashboard
6300 #[serde(
6301 rename = "dashboardUrl",
6302 default,
6303 skip_serializing_if = "::std::option::Option::is_none"
6304 )]
6305 pub dashboard_url: ::std::option::Option<::std::string::String>,
6306 #[serde(
6307 rename = "environmentId",
6308 default,
6309 skip_serializing_if = "::std::option::Option::is_none"
6310 )]
6311 pub environment_id: ::std::option::Option<::std::string::String>,
6312 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6313 pub id: ::std::option::Option<::std::string::String>,
6314 #[serde(
6315 rename = "imagePath",
6316 default,
6317 skip_serializing_if = "::std::option::Option::is_none"
6318 )]
6319 pub image_path: ::std::option::Option<::std::string::String>,
6320 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6321 pub name: ::std::option::Option<::std::string::String>,
6322 #[serde(
6323 rename = "notifyOnFail",
6324 default,
6325 skip_serializing_if = "::std::option::Option::is_none"
6326 )]
6327 pub notify_on_fail: ::std::option::Option<NotifySetting>,
6328 #[serde(
6329 rename = "ownerId",
6330 default,
6331 skip_serializing_if = "::std::option::Option::is_none"
6332 )]
6333 pub owner_id: ::std::option::Option<::std::string::String>,
6334 #[serde(
6335 rename = "registryCredential",
6336 default,
6337 skip_serializing_if = "::std::option::Option::is_none"
6338 )]
6339 pub registry_credential: ::std::option::Option<RegistryCredentialSummary>,
6340 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6341 pub repo: ::std::option::Option<::std::string::String>,
6342 #[serde(
6343 rename = "rootDir",
6344 default,
6345 skip_serializing_if = "::std::option::Option::is_none"
6346 )]
6347 pub root_dir: ::std::option::Option<::std::string::String>,
6348 #[serde(
6349 rename = "serviceDetails",
6350 default,
6351 skip_serializing_if = "::std::option::Option::is_none"
6352 )]
6353 pub service_details: ::std::option::Option<ServiceServiceDetails>,
6354 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6355 pub slug: ::std::option::Option<::std::string::String>,
6356 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6357 pub suspended: ::std::option::Option<::std::string::String>,
6358 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
6359 pub suspenders: ::std::vec::Vec<SuspenderType>,
6360 #[serde(
6361 rename = "type",
6362 default,
6363 skip_serializing_if = "::std::option::Option::is_none"
6364 )]
6365 pub type_: ::std::option::Option<ServiceType>,
6366 #[serde(
6367 rename = "updatedAt",
6368 default,
6369 skip_serializing_if = "::std::option::Option::is_none"
6370 )]
6371 pub updated_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
6372 }
6373
6374 impl ::std::default::Default for Service {
6375 fn default() -> Self {
6376 Self {
6377 auto_deploy: Default::default(),
6378 branch: Default::default(),
6379 build_filter: Default::default(),
6380 created_at: Default::default(),
6381 dashboard_url: Default::default(),
6382 environment_id: Default::default(),
6383 id: Default::default(),
6384 image_path: Default::default(),
6385 name: Default::default(),
6386 notify_on_fail: Default::default(),
6387 owner_id: Default::default(),
6388 registry_credential: Default::default(),
6389 repo: Default::default(),
6390 root_dir: Default::default(),
6391 service_details: Default::default(),
6392 slug: Default::default(),
6393 suspended: Default::default(),
6394 suspenders: Default::default(),
6395 type_: Default::default(),
6396 updated_at: Default::default(),
6397 }
6398 }
6399 }
6400
6401 ///`ServiceAndDeploy`
6402 ///
6403 /// <details><summary>JSON schema</summary>
6404 ///
6405 /// ```json
6406 ///{
6407 /// "type": "object",
6408 /// "properties": {
6409 /// "deployId": {
6410 /// "type": "string"
6411 /// },
6412 /// "service": {
6413 /// "$ref": "#/components/schemas/service"
6414 /// }
6415 /// }
6416 ///}
6417 /// ```
6418 /// </details>
6419 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6420 pub struct ServiceAndDeploy {
6421 #[serde(
6422 rename = "deployId",
6423 default,
6424 skip_serializing_if = "::std::option::Option::is_none"
6425 )]
6426 pub deploy_id: ::std::option::Option<::std::string::String>,
6427 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6428 pub service: ::std::option::Option<Service>,
6429 }
6430
6431 impl ::std::default::Default for ServiceAndDeploy {
6432 fn default() -> Self {
6433 Self {
6434 deploy_id: Default::default(),
6435 service: Default::default(),
6436 }
6437 }
6438 }
6439
6440 ///`ServiceDisk`
6441 ///
6442 /// <details><summary>JSON schema</summary>
6443 ///
6444 /// ```json
6445 ///{
6446 /// "type": "object",
6447 /// "properties": {
6448 /// "mountPath": {
6449 /// "type": "string"
6450 /// },
6451 /// "name": {
6452 /// "type": "string"
6453 /// },
6454 /// "sizeGB": {
6455 /// "description": "Defaults to 1",
6456 /// "type": "integer",
6457 /// "minimum": 1.0
6458 /// }
6459 /// }
6460 ///}
6461 /// ```
6462 /// </details>
6463 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6464 pub struct ServiceDisk {
6465 #[serde(
6466 rename = "mountPath",
6467 default,
6468 skip_serializing_if = "::std::option::Option::is_none"
6469 )]
6470 pub mount_path: ::std::option::Option<::std::string::String>,
6471 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6472 pub name: ::std::option::Option<::std::string::String>,
6473 ///Defaults to 1
6474 #[serde(
6475 rename = "sizeGB",
6476 default,
6477 skip_serializing_if = "::std::option::Option::is_none"
6478 )]
6479 pub size_gb: ::std::option::Option<::std::num::NonZeroU64>,
6480 }
6481
6482 impl ::std::default::Default for ServiceDisk {
6483 fn default() -> Self {
6484 Self {
6485 mount_path: Default::default(),
6486 name: Default::default(),
6487 size_gb: Default::default(),
6488 }
6489 }
6490 }
6491
6492 ///This field has been deprecated, runtime should be used in its place.
6493 ///
6494 /// <details><summary>JSON schema</summary>
6495 ///
6496 /// ```json
6497 ///{
6498 /// "description": "This field has been deprecated, runtime should be used
6499 /// in its place.",
6500 /// "deprecated": true,
6501 /// "type": "string"
6502 ///}
6503 /// ```
6504 /// </details>
6505 #[derive(
6506 :: serde :: Deserialize,
6507 :: serde :: Serialize,
6508 Clone,
6509 Debug,
6510 Eq,
6511 Hash,
6512 Ord,
6513 PartialEq,
6514 PartialOrd,
6515 )]
6516 #[serde(transparent)]
6517 pub struct ServiceEnv(pub ::std::string::String);
6518 impl ::std::ops::Deref for ServiceEnv {
6519 type Target = ::std::string::String;
6520 fn deref(&self) -> &::std::string::String {
6521 &self.0
6522 }
6523 }
6524
6525 impl ::std::convert::From<ServiceEnv> for ::std::string::String {
6526 fn from(value: ServiceEnv) -> Self {
6527 value.0
6528 }
6529 }
6530
6531 impl ::std::convert::From<::std::string::String> for ServiceEnv {
6532 fn from(value: ::std::string::String) -> Self {
6533 Self(value)
6534 }
6535 }
6536
6537 impl ::std::str::FromStr for ServiceEnv {
6538 type Err = ::std::convert::Infallible;
6539 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
6540 Ok(Self(value.to_string()))
6541 }
6542 }
6543
6544 impl ::std::fmt::Display for ServiceEnv {
6545 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6546 self.0.fmt(f)
6547 }
6548 }
6549
6550 ///`ServiceList`
6551 ///
6552 /// <details><summary>JSON schema</summary>
6553 ///
6554 /// ```json
6555 ///{
6556 /// "type": "array",
6557 /// "items": {
6558 /// "$ref": "#/components/schemas/serviceWithCursor"
6559 /// }
6560 ///}
6561 /// ```
6562 /// </details>
6563 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6564 #[serde(transparent)]
6565 pub struct ServiceList(pub ::std::vec::Vec<ServiceWithCursor>);
6566 impl ::std::ops::Deref for ServiceList {
6567 type Target = ::std::vec::Vec<ServiceWithCursor>;
6568 fn deref(&self) -> &::std::vec::Vec<ServiceWithCursor> {
6569 &self.0
6570 }
6571 }
6572
6573 impl ::std::convert::From<ServiceList> for ::std::vec::Vec<ServiceWithCursor> {
6574 fn from(value: ServiceList) -> Self {
6575 value.0
6576 }
6577 }
6578
6579 impl ::std::convert::From<::std::vec::Vec<ServiceWithCursor>> for ServiceList {
6580 fn from(value: ::std::vec::Vec<ServiceWithCursor>) -> Self {
6581 Self(value)
6582 }
6583 }
6584
6585 ///`ServicePost`
6586 ///
6587 /// <details><summary>JSON schema</summary>
6588 ///
6589 /// ```json
6590 ///{
6591 /// "type": "object",
6592 /// "properties": {
6593 /// "autoDeploy": {
6594 /// "$ref": "#/components/schemas/autoDeploy"
6595 /// },
6596 /// "branch": {
6597 /// "description": "The repo branch to pull, build, and deploy. If
6598 /// omitted, uses the repository's default branch.",
6599 /// "type": "string"
6600 /// },
6601 /// "buildFilter": {
6602 /// "$ref": "#/components/schemas/buildFilter"
6603 /// },
6604 /// "envVars": {
6605 /// "type": "array",
6606 /// "items": {
6607 /// "type": "object",
6608 /// "oneOf": [
6609 /// {
6610 /// "type": "object",
6611 /// "properties": {
6612 /// "key": {
6613 /// "type": "string"
6614 /// },
6615 /// "value": {
6616 /// "type": "string"
6617 /// }
6618 /// }
6619 /// },
6620 /// {
6621 /// "type": "object",
6622 /// "properties": {
6623 /// "generateValue": {
6624 /// "description": "If true, Render generates a strong random
6625 /// value for this environment variable on creation. Cannot be combined with
6626 /// `value`.",
6627 /// "type": "boolean"
6628 /// },
6629 /// "key": {
6630 /// "type": "string"
6631 /// }
6632 /// }
6633 /// }
6634 /// ]
6635 /// }
6636 /// },
6637 /// "environmentId": {
6638 /// "description": "The ID of the environment the service belongs to,
6639 /// if any. Obtain an environment's ID from its Settings page in the Render
6640 /// Dashboard.",
6641 /// "type": "string"
6642 /// },
6643 /// "image": {
6644 /// "$ref": "#/components/schemas/image"
6645 /// },
6646 /// "name": {
6647 /// "description": "The service's name. Must be unique within the
6648 /// workspace.",
6649 /// "type": "string"
6650 /// },
6651 /// "ownerId": {
6652 /// "description": "The ID of the workspace the service belongs to.
6653 /// Obtain your workspace's ID from its Settings page in the Render
6654 /// Dashboard.",
6655 /// "type": "string"
6656 /// },
6657 /// "repo": {
6658 /// "description": "The service's repository URL. Do not specify a
6659 /// branch in this string (use the `branch` parameter instead).",
6660 /// "examples": [
6661 /// "https://github.com/render-examples/flask-hello-world"
6662 /// ],
6663 /// "type": "string"
6664 /// },
6665 /// "rootDir": {
6666 /// "type": "string"
6667 /// },
6668 /// "secretFiles": {
6669 /// "type": "array",
6670 /// "items": {
6671 /// "$ref": "#/components/schemas/secretFileInput"
6672 /// }
6673 /// },
6674 /// "serviceDetails": {
6675 /// "oneOf": [
6676 /// {
6677 /// "$ref": "#/components/schemas/staticSiteDetailsPOST"
6678 /// },
6679 /// {
6680 /// "$ref": "#/components/schemas/webServiceDetailsPOST"
6681 /// },
6682 /// {
6683 /// "$ref": "#/components/schemas/privateServiceDetailsPOST"
6684 /// },
6685 /// {
6686 /// "$ref": "#/components/schemas/backgroundWorkerDetailsPOST"
6687 /// },
6688 /// {
6689 /// "$ref": "#/components/schemas/cronJobDetailsPOST"
6690 /// }
6691 /// ]
6692 /// },
6693 /// "type": {
6694 /// "$ref": "#/components/schemas/serviceType"
6695 /// }
6696 /// }
6697 ///}
6698 /// ```
6699 /// </details>
6700 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6701 pub struct ServicePost {
6702 #[serde(
6703 rename = "autoDeploy",
6704 default,
6705 skip_serializing_if = "::std::option::Option::is_none"
6706 )]
6707 pub auto_deploy: ::std::option::Option<AutoDeploy>,
6708 ///The repo branch to pull, build, and deploy. If omitted, uses the
6709 /// repository's default branch.
6710 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6711 pub branch: ::std::option::Option<::std::string::String>,
6712 #[serde(
6713 rename = "buildFilter",
6714 default,
6715 skip_serializing_if = "::std::option::Option::is_none"
6716 )]
6717 pub build_filter: ::std::option::Option<BuildFilter>,
6718 #[serde(
6719 rename = "envVars",
6720 default,
6721 skip_serializing_if = "::std::vec::Vec::is_empty"
6722 )]
6723 pub env_vars: ::std::vec::Vec<ServicePostEnvVarsItem>,
6724 ///The ID of the environment the service belongs to, if any. Obtain an
6725 /// environment's ID from its Settings page in the Render Dashboard.
6726 #[serde(
6727 rename = "environmentId",
6728 default,
6729 skip_serializing_if = "::std::option::Option::is_none"
6730 )]
6731 pub environment_id: ::std::option::Option<::std::string::String>,
6732 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6733 pub image: ::std::option::Option<Image>,
6734 ///The service's name. Must be unique within the workspace.
6735 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6736 pub name: ::std::option::Option<::std::string::String>,
6737 ///The ID of the workspace the service belongs to. Obtain your
6738 /// workspace's ID from its Settings page in the Render Dashboard.
6739 #[serde(
6740 rename = "ownerId",
6741 default,
6742 skip_serializing_if = "::std::option::Option::is_none"
6743 )]
6744 pub owner_id: ::std::option::Option<::std::string::String>,
6745 ///The service's repository URL. Do not specify a branch in this string
6746 /// (use the `branch` parameter instead).
6747 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6748 pub repo: ::std::option::Option<::std::string::String>,
6749 #[serde(
6750 rename = "rootDir",
6751 default,
6752 skip_serializing_if = "::std::option::Option::is_none"
6753 )]
6754 pub root_dir: ::std::option::Option<::std::string::String>,
6755 #[serde(
6756 rename = "secretFiles",
6757 default,
6758 skip_serializing_if = "::std::vec::Vec::is_empty"
6759 )]
6760 pub secret_files: ::std::vec::Vec<SecretFileInput>,
6761 #[serde(
6762 rename = "serviceDetails",
6763 default,
6764 skip_serializing_if = "::std::option::Option::is_none"
6765 )]
6766 pub service_details: ::std::option::Option<ServicePostServiceDetails>,
6767 #[serde(
6768 rename = "type",
6769 default,
6770 skip_serializing_if = "::std::option::Option::is_none"
6771 )]
6772 pub type_: ::std::option::Option<ServiceType>,
6773 }
6774
6775 impl ::std::default::Default for ServicePost {
6776 fn default() -> Self {
6777 Self {
6778 auto_deploy: Default::default(),
6779 branch: Default::default(),
6780 build_filter: Default::default(),
6781 env_vars: Default::default(),
6782 environment_id: Default::default(),
6783 image: Default::default(),
6784 name: Default::default(),
6785 owner_id: Default::default(),
6786 repo: Default::default(),
6787 root_dir: Default::default(),
6788 secret_files: Default::default(),
6789 service_details: Default::default(),
6790 type_: Default::default(),
6791 }
6792 }
6793 }
6794
6795 ///`ServicePostEnvVarsItem`
6796 ///
6797 /// <details><summary>JSON schema</summary>
6798 ///
6799 /// ```json
6800 ///{
6801 /// "type": "object",
6802 /// "oneOf": [
6803 /// {
6804 /// "type": "object",
6805 /// "properties": {
6806 /// "key": {
6807 /// "type": "string"
6808 /// },
6809 /// "value": {
6810 /// "type": "string"
6811 /// }
6812 /// }
6813 /// },
6814 /// {
6815 /// "type": "object",
6816 /// "properties": {
6817 /// "generateValue": {
6818 /// "description": "If true, Render generates a strong random value
6819 /// for this environment variable on creation. Cannot be combined with
6820 /// `value`.",
6821 /// "type": "boolean"
6822 /// },
6823 /// "key": {
6824 /// "type": "string"
6825 /// }
6826 /// }
6827 /// }
6828 /// ]
6829 ///}
6830 /// ```
6831 /// </details>
6832 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6833 #[serde(untagged)]
6834 pub enum ServicePostEnvVarsItem {
6835 Variant0 {
6836 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6837 key: ::std::option::Option<::std::string::String>,
6838 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6839 value: ::std::option::Option<::std::string::String>,
6840 },
6841 Variant1 {
6842 ///If true, Render generates a strong random value for this
6843 /// environment variable on creation. Cannot be combined with
6844 /// `value`.
6845 #[serde(
6846 rename = "generateValue",
6847 default,
6848 skip_serializing_if = "::std::option::Option::is_none"
6849 )]
6850 generate_value: ::std::option::Option<bool>,
6851 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
6852 key: ::std::option::Option<::std::string::String>,
6853 },
6854 }
6855
6856 ///`ServicePostServiceDetails`
6857 ///
6858 /// <details><summary>JSON schema</summary>
6859 ///
6860 /// ```json
6861 ///{
6862 /// "oneOf": [
6863 /// {
6864 /// "$ref": "#/components/schemas/staticSiteDetailsPOST"
6865 /// },
6866 /// {
6867 /// "$ref": "#/components/schemas/webServiceDetailsPOST"
6868 /// },
6869 /// {
6870 /// "$ref": "#/components/schemas/privateServiceDetailsPOST"
6871 /// },
6872 /// {
6873 /// "$ref": "#/components/schemas/backgroundWorkerDetailsPOST"
6874 /// },
6875 /// {
6876 /// "$ref": "#/components/schemas/cronJobDetailsPOST"
6877 /// }
6878 /// ]
6879 ///}
6880 /// ```
6881 /// </details>
6882 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
6883 #[serde(untagged)]
6884 pub enum ServicePostServiceDetails {
6885 StaticSiteDetailsPost(StaticSiteDetailsPost),
6886 WebServiceDetailsPost(WebServiceDetailsPost),
6887 PrivateServiceDetailsPost(PrivateServiceDetailsPost),
6888 BackgroundWorkerDetailsPost(BackgroundWorkerDetailsPost),
6889 CronJobDetailsPost(CronJobDetailsPost),
6890 }
6891
6892 impl ::std::convert::From<StaticSiteDetailsPost> for ServicePostServiceDetails {
6893 fn from(value: StaticSiteDetailsPost) -> Self {
6894 Self::StaticSiteDetailsPost(value)
6895 }
6896 }
6897
6898 impl ::std::convert::From<WebServiceDetailsPost> for ServicePostServiceDetails {
6899 fn from(value: WebServiceDetailsPost) -> Self {
6900 Self::WebServiceDetailsPost(value)
6901 }
6902 }
6903
6904 impl ::std::convert::From<PrivateServiceDetailsPost> for ServicePostServiceDetails {
6905 fn from(value: PrivateServiceDetailsPost) -> Self {
6906 Self::PrivateServiceDetailsPost(value)
6907 }
6908 }
6909
6910 impl ::std::convert::From<BackgroundWorkerDetailsPost> for ServicePostServiceDetails {
6911 fn from(value: BackgroundWorkerDetailsPost) -> Self {
6912 Self::BackgroundWorkerDetailsPost(value)
6913 }
6914 }
6915
6916 impl ::std::convert::From<CronJobDetailsPost> for ServicePostServiceDetails {
6917 fn from(value: CronJobDetailsPost) -> Self {
6918 Self::CronJobDetailsPost(value)
6919 }
6920 }
6921
6922 ///Runtime
6923 ///
6924 /// <details><summary>JSON schema</summary>
6925 ///
6926 /// ```json
6927 ///{
6928 /// "description": "Runtime",
6929 /// "type": "string"
6930 ///}
6931 /// ```
6932 /// </details>
6933 #[derive(
6934 :: serde :: Deserialize,
6935 :: serde :: Serialize,
6936 Clone,
6937 Debug,
6938 Eq,
6939 Hash,
6940 Ord,
6941 PartialEq,
6942 PartialOrd,
6943 )]
6944 #[serde(transparent)]
6945 pub struct ServiceRuntime(pub ::std::string::String);
6946 impl ::std::ops::Deref for ServiceRuntime {
6947 type Target = ::std::string::String;
6948 fn deref(&self) -> &::std::string::String {
6949 &self.0
6950 }
6951 }
6952
6953 impl ::std::convert::From<ServiceRuntime> for ::std::string::String {
6954 fn from(value: ServiceRuntime) -> Self {
6955 value.0
6956 }
6957 }
6958
6959 impl ::std::convert::From<::std::string::String> for ServiceRuntime {
6960 fn from(value: ::std::string::String) -> Self {
6961 Self(value)
6962 }
6963 }
6964
6965 impl ::std::str::FromStr for ServiceRuntime {
6966 type Err = ::std::convert::Infallible;
6967 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
6968 Ok(Self(value.to_string()))
6969 }
6970 }
6971
6972 impl ::std::fmt::Display for ServiceRuntime {
6973 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6974 self.0.fmt(f)
6975 }
6976 }
6977
6978 ///`ServiceServiceDetails`
6979 ///
6980 /// <details><summary>JSON schema</summary>
6981 ///
6982 /// ```json
6983 ///{
6984 /// "oneOf": [
6985 /// {
6986 /// "$ref": "#/components/schemas/staticSiteDetails"
6987 /// },
6988 /// {
6989 /// "$ref": "#/components/schemas/webServiceDetails"
6990 /// },
6991 /// {
6992 /// "$ref": "#/components/schemas/privateServiceDetails"
6993 /// },
6994 /// {
6995 /// "$ref": "#/components/schemas/backgroundWorkerDetails"
6996 /// },
6997 /// {
6998 /// "$ref": "#/components/schemas/cronJobDetails"
6999 /// }
7000 /// ]
7001 ///}
7002 /// ```
7003 /// </details>
7004 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7005 #[serde(untagged)]
7006 pub enum ServiceServiceDetails {
7007 StaticSiteDetails(StaticSiteDetails),
7008 WebServiceDetails(WebServiceDetails),
7009 PrivateServiceDetails(PrivateServiceDetails),
7010 BackgroundWorkerDetails(BackgroundWorkerDetails),
7011 CronJobDetails(CronJobDetails),
7012 }
7013
7014 impl ::std::convert::From<StaticSiteDetails> for ServiceServiceDetails {
7015 fn from(value: StaticSiteDetails) -> Self {
7016 Self::StaticSiteDetails(value)
7017 }
7018 }
7019
7020 impl ::std::convert::From<WebServiceDetails> for ServiceServiceDetails {
7021 fn from(value: WebServiceDetails) -> Self {
7022 Self::WebServiceDetails(value)
7023 }
7024 }
7025
7026 impl ::std::convert::From<PrivateServiceDetails> for ServiceServiceDetails {
7027 fn from(value: PrivateServiceDetails) -> Self {
7028 Self::PrivateServiceDetails(value)
7029 }
7030 }
7031
7032 impl ::std::convert::From<BackgroundWorkerDetails> for ServiceServiceDetails {
7033 fn from(value: BackgroundWorkerDetails) -> Self {
7034 Self::BackgroundWorkerDetails(value)
7035 }
7036 }
7037
7038 impl ::std::convert::From<CronJobDetails> for ServiceServiceDetails {
7039 fn from(value: CronJobDetails) -> Self {
7040 Self::CronJobDetails(value)
7041 }
7042 }
7043
7044 ///`ServiceType`
7045 ///
7046 /// <details><summary>JSON schema</summary>
7047 ///
7048 /// ```json
7049 ///{
7050 /// "type": "string"
7051 ///}
7052 /// ```
7053 /// </details>
7054 #[derive(
7055 :: serde :: Deserialize,
7056 :: serde :: Serialize,
7057 Clone,
7058 Debug,
7059 Eq,
7060 Hash,
7061 Ord,
7062 PartialEq,
7063 PartialOrd,
7064 )]
7065 #[serde(transparent)]
7066 pub struct ServiceType(pub ::std::string::String);
7067 impl ::std::ops::Deref for ServiceType {
7068 type Target = ::std::string::String;
7069 fn deref(&self) -> &::std::string::String {
7070 &self.0
7071 }
7072 }
7073
7074 impl ::std::convert::From<ServiceType> for ::std::string::String {
7075 fn from(value: ServiceType) -> Self {
7076 value.0
7077 }
7078 }
7079
7080 impl ::std::convert::From<::std::string::String> for ServiceType {
7081 fn from(value: ::std::string::String) -> Self {
7082 Self(value)
7083 }
7084 }
7085
7086 impl ::std::str::FromStr for ServiceType {
7087 type Err = ::std::convert::Infallible;
7088 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
7089 Ok(Self(value.to_string()))
7090 }
7091 }
7092
7093 impl ::std::fmt::Display for ServiceType {
7094 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7095 self.0.fmt(f)
7096 }
7097 }
7098
7099 ///`ServiceWithCursor`
7100 ///
7101 /// <details><summary>JSON schema</summary>
7102 ///
7103 /// ```json
7104 ///{
7105 /// "type": "object",
7106 /// "properties": {
7107 /// "cursor": {
7108 /// "$ref": "#/components/schemas/cursor"
7109 /// },
7110 /// "service": {
7111 /// "$ref": "#/components/schemas/service"
7112 /// }
7113 /// }
7114 ///}
7115 /// ```
7116 /// </details>
7117 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7118 pub struct ServiceWithCursor {
7119 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7120 pub cursor: ::std::option::Option<Cursor>,
7121 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7122 pub service: ::std::option::Option<Service>,
7123 }
7124
7125 impl ::std::default::Default for ServiceWithCursor {
7126 fn default() -> Self {
7127 Self {
7128 cursor: Default::default(),
7129 service: Default::default(),
7130 }
7131 }
7132 }
7133
7134 ///The SSH address for the service. Only present for services that have SSH
7135 /// enabled.
7136 ///
7137 /// <details><summary>JSON schema</summary>
7138 ///
7139 /// ```json
7140 ///{
7141 /// "description": "The SSH address for the service. Only present for
7142 /// services that have SSH enabled.",
7143 /// "type": "string"
7144 ///}
7145 /// ```
7146 /// </details>
7147 #[derive(
7148 :: serde :: Deserialize,
7149 :: serde :: Serialize,
7150 Clone,
7151 Debug,
7152 Eq,
7153 Hash,
7154 Ord,
7155 PartialEq,
7156 PartialOrd,
7157 )]
7158 #[serde(transparent)]
7159 pub struct SshAddress(pub ::std::string::String);
7160 impl ::std::ops::Deref for SshAddress {
7161 type Target = ::std::string::String;
7162 fn deref(&self) -> &::std::string::String {
7163 &self.0
7164 }
7165 }
7166
7167 impl ::std::convert::From<SshAddress> for ::std::string::String {
7168 fn from(value: SshAddress) -> Self {
7169 value.0
7170 }
7171 }
7172
7173 impl ::std::convert::From<::std::string::String> for SshAddress {
7174 fn from(value: ::std::string::String) -> Self {
7175 Self(value)
7176 }
7177 }
7178
7179 impl ::std::str::FromStr for SshAddress {
7180 type Err = ::std::convert::Infallible;
7181 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
7182 Ok(Self(value.to_string()))
7183 }
7184 }
7185
7186 impl ::std::fmt::Display for SshAddress {
7187 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7188 self.0.fmt(f)
7189 }
7190 }
7191
7192 ///`StaticSiteDetails`
7193 ///
7194 /// <details><summary>JSON schema</summary>
7195 ///
7196 /// ```json
7197 ///{
7198 /// "type": "object",
7199 /// "properties": {
7200 /// "buildCommand": {
7201 /// "type": "string"
7202 /// },
7203 /// "buildPlan": {
7204 /// "$ref": "#/components/schemas/buildPlan"
7205 /// },
7206 /// "ipAllowList": {
7207 /// "type": "array",
7208 /// "items": {
7209 /// "$ref": "#/components/schemas/cidrBlockAndDescription"
7210 /// }
7211 /// },
7212 /// "parentServer": {
7213 /// "$ref": "#/components/schemas/resource"
7214 /// },
7215 /// "previews": {
7216 /// "$ref": "#/components/schemas/previews"
7217 /// },
7218 /// "publishPath": {
7219 /// "type": "string"
7220 /// },
7221 /// "pullRequestPreviewsEnabled": {
7222 /// "$ref": "#/components/schemas/pullRequestPreviewsEnabled"
7223 /// },
7224 /// "renderSubdomainPolicy": {
7225 /// "$ref": "#/components/schemas/renderSubdomainPolicy"
7226 /// },
7227 /// "url": {
7228 /// "type": "string"
7229 /// }
7230 /// }
7231 ///}
7232 /// ```
7233 /// </details>
7234 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7235 pub struct StaticSiteDetails {
7236 #[serde(
7237 rename = "buildCommand",
7238 default,
7239 skip_serializing_if = "::std::option::Option::is_none"
7240 )]
7241 pub build_command: ::std::option::Option<::std::string::String>,
7242 #[serde(
7243 rename = "buildPlan",
7244 default,
7245 skip_serializing_if = "::std::option::Option::is_none"
7246 )]
7247 pub build_plan: ::std::option::Option<BuildPlan>,
7248 #[serde(
7249 rename = "ipAllowList",
7250 default,
7251 skip_serializing_if = "::std::vec::Vec::is_empty"
7252 )]
7253 pub ip_allow_list: ::std::vec::Vec<CidrBlockAndDescription>,
7254 #[serde(
7255 rename = "parentServer",
7256 default,
7257 skip_serializing_if = "::std::option::Option::is_none"
7258 )]
7259 pub parent_server: ::std::option::Option<Resource>,
7260 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7261 pub previews: ::std::option::Option<Previews>,
7262 #[serde(
7263 rename = "publishPath",
7264 default,
7265 skip_serializing_if = "::std::option::Option::is_none"
7266 )]
7267 pub publish_path: ::std::option::Option<::std::string::String>,
7268 #[serde(
7269 rename = "pullRequestPreviewsEnabled",
7270 default,
7271 skip_serializing_if = "::std::option::Option::is_none"
7272 )]
7273 pub pull_request_previews_enabled: ::std::option::Option<PullRequestPreviewsEnabled>,
7274 #[serde(
7275 rename = "renderSubdomainPolicy",
7276 default,
7277 skip_serializing_if = "::std::option::Option::is_none"
7278 )]
7279 pub render_subdomain_policy: ::std::option::Option<RenderSubdomainPolicy>,
7280 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7281 pub url: ::std::option::Option<::std::string::String>,
7282 }
7283
7284 impl ::std::default::Default for StaticSiteDetails {
7285 fn default() -> Self {
7286 Self {
7287 build_command: Default::default(),
7288 build_plan: Default::default(),
7289 ip_allow_list: Default::default(),
7290 parent_server: Default::default(),
7291 previews: Default::default(),
7292 publish_path: Default::default(),
7293 pull_request_previews_enabled: Default::default(),
7294 render_subdomain_policy: Default::default(),
7295 url: Default::default(),
7296 }
7297 }
7298 }
7299
7300 ///`StaticSiteDetailsPost`
7301 ///
7302 /// <details><summary>JSON schema</summary>
7303 ///
7304 /// ```json
7305 ///{
7306 /// "type": "object",
7307 /// "properties": {
7308 /// "buildCommand": {
7309 /// "type": "string"
7310 /// },
7311 /// "headers": {
7312 /// "type": "array",
7313 /// "items": {
7314 /// "$ref": "#/components/schemas/headerInput"
7315 /// }
7316 /// },
7317 /// "ipAllowList": {
7318 /// "type": "array",
7319 /// "items": {
7320 /// "$ref": "#/components/schemas/cidrBlockAndDescription"
7321 /// }
7322 /// },
7323 /// "previews": {
7324 /// "$ref": "#/components/schemas/previews"
7325 /// },
7326 /// "publishPath": {
7327 /// "description": "Defaults to \"public\"",
7328 /// "type": "string"
7329 /// },
7330 /// "pullRequestPreviewsEnabled": {
7331 /// "$ref": "#/components/schemas/pullRequestPreviewsEnabled"
7332 /// },
7333 /// "renderSubdomainPolicy": {
7334 /// "$ref": "#/components/schemas/renderSubdomainPolicy"
7335 /// },
7336 /// "routes": {
7337 /// "type": "array",
7338 /// "items": {
7339 /// "$ref": "#/components/schemas/routePost"
7340 /// }
7341 /// }
7342 /// }
7343 ///}
7344 /// ```
7345 /// </details>
7346 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7347 pub struct StaticSiteDetailsPost {
7348 #[serde(
7349 rename = "buildCommand",
7350 default,
7351 skip_serializing_if = "::std::option::Option::is_none"
7352 )]
7353 pub build_command: ::std::option::Option<::std::string::String>,
7354 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
7355 pub headers: ::std::vec::Vec<HeaderInput>,
7356 #[serde(
7357 rename = "ipAllowList",
7358 default,
7359 skip_serializing_if = "::std::vec::Vec::is_empty"
7360 )]
7361 pub ip_allow_list: ::std::vec::Vec<CidrBlockAndDescription>,
7362 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7363 pub previews: ::std::option::Option<Previews>,
7364 ///Defaults to "public"
7365 #[serde(
7366 rename = "publishPath",
7367 default,
7368 skip_serializing_if = "::std::option::Option::is_none"
7369 )]
7370 pub publish_path: ::std::option::Option<::std::string::String>,
7371 #[serde(
7372 rename = "pullRequestPreviewsEnabled",
7373 default,
7374 skip_serializing_if = "::std::option::Option::is_none"
7375 )]
7376 pub pull_request_previews_enabled: ::std::option::Option<PullRequestPreviewsEnabled>,
7377 #[serde(
7378 rename = "renderSubdomainPolicy",
7379 default,
7380 skip_serializing_if = "::std::option::Option::is_none"
7381 )]
7382 pub render_subdomain_policy: ::std::option::Option<RenderSubdomainPolicy>,
7383 #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
7384 pub routes: ::std::vec::Vec<RoutePost>,
7385 }
7386
7387 impl ::std::default::Default for StaticSiteDetailsPost {
7388 fn default() -> Self {
7389 Self {
7390 build_command: Default::default(),
7391 headers: Default::default(),
7392 ip_allow_list: Default::default(),
7393 previews: Default::default(),
7394 publish_path: Default::default(),
7395 pull_request_previews_enabled: Default::default(),
7396 render_subdomain_policy: Default::default(),
7397 routes: Default::default(),
7398 }
7399 }
7400 }
7401
7402 ///`SuspenderType`
7403 ///
7404 /// <details><summary>JSON schema</summary>
7405 ///
7406 /// ```json
7407 ///{
7408 /// "type": "string"
7409 ///}
7410 /// ```
7411 /// </details>
7412 #[derive(
7413 :: serde :: Deserialize,
7414 :: serde :: Serialize,
7415 Clone,
7416 Debug,
7417 Eq,
7418 Hash,
7419 Ord,
7420 PartialEq,
7421 PartialOrd,
7422 )]
7423 #[serde(transparent)]
7424 pub struct SuspenderType(pub ::std::string::String);
7425 impl ::std::ops::Deref for SuspenderType {
7426 type Target = ::std::string::String;
7427 fn deref(&self) -> &::std::string::String {
7428 &self.0
7429 }
7430 }
7431
7432 impl ::std::convert::From<SuspenderType> for ::std::string::String {
7433 fn from(value: SuspenderType) -> Self {
7434 value.0
7435 }
7436 }
7437
7438 impl ::std::convert::From<::std::string::String> for SuspenderType {
7439 fn from(value: ::std::string::String) -> Self {
7440 Self(value)
7441 }
7442 }
7443
7444 impl ::std::str::FromStr for SuspenderType {
7445 type Err = ::std::convert::Infallible;
7446 fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
7447 Ok(Self(value.to_string()))
7448 }
7449 }
7450
7451 impl ::std::fmt::Display for SuspenderType {
7452 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7453 self.0.fmt(f)
7454 }
7455 }
7456
7457 ///`UpdateEnvVarsForServiceBodyItem`
7458 ///
7459 /// <details><summary>JSON schema</summary>
7460 ///
7461 /// ```json
7462 ///{
7463 /// "type": "object",
7464 /// "oneOf": [
7465 /// {
7466 /// "type": "object",
7467 /// "properties": {
7468 /// "key": {
7469 /// "type": "string"
7470 /// },
7471 /// "value": {
7472 /// "type": "string"
7473 /// }
7474 /// }
7475 /// },
7476 /// {
7477 /// "type": "object",
7478 /// "properties": {
7479 /// "generateValue": {
7480 /// "description": "If true, Render generates a strong random value
7481 /// for this environment variable on creation. Cannot be combined with
7482 /// `value`.",
7483 /// "type": "boolean"
7484 /// },
7485 /// "key": {
7486 /// "type": "string"
7487 /// }
7488 /// }
7489 /// }
7490 /// ]
7491 ///}
7492 /// ```
7493 /// </details>
7494 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7495 #[serde(untagged)]
7496 pub enum UpdateEnvVarsForServiceBodyItem {
7497 Variant0 {
7498 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7499 key: ::std::option::Option<::std::string::String>,
7500 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7501 value: ::std::option::Option<::std::string::String>,
7502 },
7503 Variant1 {
7504 ///If true, Render generates a strong random value for this
7505 /// environment variable on creation. Cannot be combined with
7506 /// `value`.
7507 #[serde(
7508 rename = "generateValue",
7509 default,
7510 skip_serializing_if = "::std::option::Option::is_none"
7511 )]
7512 generate_value: ::std::option::Option<bool>,
7513 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7514 key: ::std::option::Option<::std::string::String>,
7515 },
7516 }
7517
7518 ///`WebServiceDetails`
7519 ///
7520 /// <details><summary>JSON schema</summary>
7521 ///
7522 /// ```json
7523 ///{
7524 /// "type": "object",
7525 /// "properties": {
7526 /// "autoscaling": {
7527 /// "type": "object",
7528 /// "properties": {
7529 /// "criteria": {
7530 /// "type": "object",
7531 /// "properties": {
7532 /// "cpu": {
7533 /// "type": "object",
7534 /// "properties": {
7535 /// "enabled": {
7536 /// "default": false,
7537 /// "type": "boolean"
7538 /// },
7539 /// "percentage": {
7540 /// "description": "Determines when your service will be
7541 /// scaled. If the average resource utilization is significantly above/below
7542 /// the target, we will increase/decrease the number of instances.\n",
7543 /// "type": "integer"
7544 /// }
7545 /// }
7546 /// },
7547 /// "memory": {
7548 /// "type": "object",
7549 /// "properties": {
7550 /// "enabled": {
7551 /// "default": false,
7552 /// "type": "boolean"
7553 /// },
7554 /// "percentage": {
7555 /// "description": "Determines when your service will be
7556 /// scaled. If the average resource utilization is significantly above/below
7557 /// the target, we will increase/decrease the number of instances.\n",
7558 /// "type": "integer"
7559 /// }
7560 /// }
7561 /// }
7562 /// }
7563 /// },
7564 /// "enabled": {
7565 /// "default": false,
7566 /// "type": "boolean"
7567 /// },
7568 /// "max": {
7569 /// "description": "The maximum number of instances for the
7570 /// service",
7571 /// "type": "integer"
7572 /// },
7573 /// "min": {
7574 /// "description": "The minimum number of instances for the
7575 /// service",
7576 /// "type": "integer"
7577 /// }
7578 /// }
7579 /// },
7580 /// "buildPlan": {
7581 /// "$ref": "#/components/schemas/buildPlan"
7582 /// },
7583 /// "cache": {
7584 /// "$ref": "#/components/schemas/cache"
7585 /// },
7586 /// "disk": {
7587 /// "type": "object",
7588 /// "properties": {
7589 /// "id": {
7590 /// "examples": [
7591 /// "dsk-cph1rs3idesc73a2b2mg"
7592 /// ],
7593 /// "type": "string",
7594 /// "pattern": "^dsk-[0-9a-z]{20}$"
7595 /// },
7596 /// "mountPath": {
7597 /// "type": "string"
7598 /// },
7599 /// "name": {
7600 /// "type": "string"
7601 /// },
7602 /// "sizeGB": {
7603 /// "type": "integer"
7604 /// }
7605 /// }
7606 /// },
7607 /// "env": {
7608 /// "$ref": "#/components/schemas/serviceEnv"
7609 /// },
7610 /// "envSpecificDetails": {
7611 /// "$ref": "#/components/schemas/envSpecificDetails"
7612 /// },
7613 /// "healthCheckPath": {
7614 /// "type": "string"
7615 /// },
7616 /// "ipAllowList": {
7617 /// "type": "array",
7618 /// "items": {
7619 /// "$ref": "#/components/schemas/cidrBlockAndDescription"
7620 /// }
7621 /// },
7622 /// "maintenanceMode": {
7623 /// "$ref": "#/components/schemas/maintenanceMode"
7624 /// },
7625 /// "maxShutdownDelaySeconds": {
7626 /// "$ref": "#/components/schemas/maxShutdownDelaySeconds"
7627 /// },
7628 /// "numInstances": {
7629 /// "description": "For a *manually* scaled service, this is the number
7630 /// of instances the service is scaled to. DOES NOT indicate the number of
7631 /// running instances for an *autoscaled* service.",
7632 /// "type": "integer"
7633 /// },
7634 /// "openPorts": {
7635 /// "type": "array",
7636 /// "items": {
7637 /// "$ref": "#/components/schemas/serverPort"
7638 /// }
7639 /// },
7640 /// "parentServer": {
7641 /// "$ref": "#/components/schemas/resource"
7642 /// },
7643 /// "plan": {
7644 /// "$ref": "#/components/schemas/plan"
7645 /// },
7646 /// "previews": {
7647 /// "$ref": "#/components/schemas/previews"
7648 /// },
7649 /// "pullRequestPreviewsEnabled": {
7650 /// "$ref": "#/components/schemas/pullRequestPreviewsEnabled"
7651 /// },
7652 /// "region": {
7653 /// "$ref": "#/components/schemas/region"
7654 /// },
7655 /// "renderSubdomainPolicy": {
7656 /// "$ref": "#/components/schemas/renderSubdomainPolicy"
7657 /// },
7658 /// "runtime": {
7659 /// "$ref": "#/components/schemas/serviceRuntime"
7660 /// },
7661 /// "sshAddress": {
7662 /// "$ref": "#/components/schemas/sshAddress"
7663 /// },
7664 /// "url": {
7665 /// "type": "string"
7666 /// }
7667 /// }
7668 ///}
7669 /// ```
7670 /// </details>
7671 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7672 pub struct WebServiceDetails {
7673 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7674 pub autoscaling: ::std::option::Option<WebServiceDetailsAutoscaling>,
7675 #[serde(
7676 rename = "buildPlan",
7677 default,
7678 skip_serializing_if = "::std::option::Option::is_none"
7679 )]
7680 pub build_plan: ::std::option::Option<BuildPlan>,
7681 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7682 pub cache: ::std::option::Option<Cache>,
7683 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7684 pub disk: ::std::option::Option<WebServiceDetailsDisk>,
7685 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7686 pub env: ::std::option::Option<ServiceEnv>,
7687 #[serde(
7688 rename = "envSpecificDetails",
7689 default,
7690 skip_serializing_if = "::std::option::Option::is_none"
7691 )]
7692 pub env_specific_details: ::std::option::Option<EnvSpecificDetails>,
7693 #[serde(
7694 rename = "healthCheckPath",
7695 default,
7696 skip_serializing_if = "::std::option::Option::is_none"
7697 )]
7698 pub health_check_path: ::std::option::Option<::std::string::String>,
7699 #[serde(
7700 rename = "ipAllowList",
7701 default,
7702 skip_serializing_if = "::std::vec::Vec::is_empty"
7703 )]
7704 pub ip_allow_list: ::std::vec::Vec<CidrBlockAndDescription>,
7705 #[serde(
7706 rename = "maintenanceMode",
7707 default,
7708 skip_serializing_if = "::std::option::Option::is_none"
7709 )]
7710 pub maintenance_mode: ::std::option::Option<MaintenanceMode>,
7711 #[serde(
7712 rename = "maxShutdownDelaySeconds",
7713 default,
7714 skip_serializing_if = "::std::option::Option::is_none"
7715 )]
7716 pub max_shutdown_delay_seconds: ::std::option::Option<MaxShutdownDelaySeconds>,
7717 ///For a *manually* scaled service, this is the number of instances the
7718 /// service is scaled to. DOES NOT indicate the number of running
7719 /// instances for an *autoscaled* service.
7720 #[serde(
7721 rename = "numInstances",
7722 default,
7723 skip_serializing_if = "::std::option::Option::is_none"
7724 )]
7725 pub num_instances: ::std::option::Option<i64>,
7726 #[serde(
7727 rename = "openPorts",
7728 default,
7729 skip_serializing_if = "::std::vec::Vec::is_empty"
7730 )]
7731 pub open_ports: ::std::vec::Vec<ServerPort>,
7732 #[serde(
7733 rename = "parentServer",
7734 default,
7735 skip_serializing_if = "::std::option::Option::is_none"
7736 )]
7737 pub parent_server: ::std::option::Option<Resource>,
7738 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7739 pub plan: ::std::option::Option<Plan>,
7740 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7741 pub previews: ::std::option::Option<Previews>,
7742 #[serde(
7743 rename = "pullRequestPreviewsEnabled",
7744 default,
7745 skip_serializing_if = "::std::option::Option::is_none"
7746 )]
7747 pub pull_request_previews_enabled: ::std::option::Option<PullRequestPreviewsEnabled>,
7748 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7749 pub region: ::std::option::Option<Region>,
7750 #[serde(
7751 rename = "renderSubdomainPolicy",
7752 default,
7753 skip_serializing_if = "::std::option::Option::is_none"
7754 )]
7755 pub render_subdomain_policy: ::std::option::Option<RenderSubdomainPolicy>,
7756 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7757 pub runtime: ::std::option::Option<ServiceRuntime>,
7758 #[serde(
7759 rename = "sshAddress",
7760 default,
7761 skip_serializing_if = "::std::option::Option::is_none"
7762 )]
7763 pub ssh_address: ::std::option::Option<SshAddress>,
7764 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7765 pub url: ::std::option::Option<::std::string::String>,
7766 }
7767
7768 impl ::std::default::Default for WebServiceDetails {
7769 fn default() -> Self {
7770 Self {
7771 autoscaling: Default::default(),
7772 build_plan: Default::default(),
7773 cache: Default::default(),
7774 disk: Default::default(),
7775 env: Default::default(),
7776 env_specific_details: Default::default(),
7777 health_check_path: Default::default(),
7778 ip_allow_list: Default::default(),
7779 maintenance_mode: Default::default(),
7780 max_shutdown_delay_seconds: Default::default(),
7781 num_instances: Default::default(),
7782 open_ports: Default::default(),
7783 parent_server: Default::default(),
7784 plan: Default::default(),
7785 previews: Default::default(),
7786 pull_request_previews_enabled: Default::default(),
7787 region: Default::default(),
7788 render_subdomain_policy: Default::default(),
7789 runtime: Default::default(),
7790 ssh_address: Default::default(),
7791 url: Default::default(),
7792 }
7793 }
7794 }
7795
7796 ///`WebServiceDetailsAutoscaling`
7797 ///
7798 /// <details><summary>JSON schema</summary>
7799 ///
7800 /// ```json
7801 ///{
7802 /// "type": "object",
7803 /// "properties": {
7804 /// "criteria": {
7805 /// "type": "object",
7806 /// "properties": {
7807 /// "cpu": {
7808 /// "type": "object",
7809 /// "properties": {
7810 /// "enabled": {
7811 /// "default": false,
7812 /// "type": "boolean"
7813 /// },
7814 /// "percentage": {
7815 /// "description": "Determines when your service will be
7816 /// scaled. If the average resource utilization is significantly above/below
7817 /// the target, we will increase/decrease the number of instances.\n",
7818 /// "type": "integer"
7819 /// }
7820 /// }
7821 /// },
7822 /// "memory": {
7823 /// "type": "object",
7824 /// "properties": {
7825 /// "enabled": {
7826 /// "default": false,
7827 /// "type": "boolean"
7828 /// },
7829 /// "percentage": {
7830 /// "description": "Determines when your service will be
7831 /// scaled. If the average resource utilization is significantly above/below
7832 /// the target, we will increase/decrease the number of instances.\n",
7833 /// "type": "integer"
7834 /// }
7835 /// }
7836 /// }
7837 /// }
7838 /// },
7839 /// "enabled": {
7840 /// "default": false,
7841 /// "type": "boolean"
7842 /// },
7843 /// "max": {
7844 /// "description": "The maximum number of instances for the service",
7845 /// "type": "integer"
7846 /// },
7847 /// "min": {
7848 /// "description": "The minimum number of instances for the service",
7849 /// "type": "integer"
7850 /// }
7851 /// }
7852 ///}
7853 /// ```
7854 /// </details>
7855 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7856 pub struct WebServiceDetailsAutoscaling {
7857 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7858 pub criteria: ::std::option::Option<WebServiceDetailsAutoscalingCriteria>,
7859 #[serde(default)]
7860 pub enabled: bool,
7861 ///The maximum number of instances for the service
7862 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7863 pub max: ::std::option::Option<i64>,
7864 ///The minimum number of instances for the service
7865 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7866 pub min: ::std::option::Option<i64>,
7867 }
7868
7869 impl ::std::default::Default for WebServiceDetailsAutoscaling {
7870 fn default() -> Self {
7871 Self {
7872 criteria: Default::default(),
7873 enabled: Default::default(),
7874 max: Default::default(),
7875 min: Default::default(),
7876 }
7877 }
7878 }
7879
7880 ///`WebServiceDetailsAutoscalingCriteria`
7881 ///
7882 /// <details><summary>JSON schema</summary>
7883 ///
7884 /// ```json
7885 ///{
7886 /// "type": "object",
7887 /// "properties": {
7888 /// "cpu": {
7889 /// "type": "object",
7890 /// "properties": {
7891 /// "enabled": {
7892 /// "default": false,
7893 /// "type": "boolean"
7894 /// },
7895 /// "percentage": {
7896 /// "description": "Determines when your service will be scaled. If
7897 /// the average resource utilization is significantly above/below the
7898 /// target, we will increase/decrease the number of instances.\n",
7899 /// "type": "integer"
7900 /// }
7901 /// }
7902 /// },
7903 /// "memory": {
7904 /// "type": "object",
7905 /// "properties": {
7906 /// "enabled": {
7907 /// "default": false,
7908 /// "type": "boolean"
7909 /// },
7910 /// "percentage": {
7911 /// "description": "Determines when your service will be scaled. If
7912 /// the average resource utilization is significantly above/below the
7913 /// target, we will increase/decrease the number of instances.\n",
7914 /// "type": "integer"
7915 /// }
7916 /// }
7917 /// }
7918 /// }
7919 ///}
7920 /// ```
7921 /// </details>
7922 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7923 pub struct WebServiceDetailsAutoscalingCriteria {
7924 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7925 pub cpu: ::std::option::Option<WebServiceDetailsAutoscalingCriteriaCpu>,
7926 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7927 pub memory: ::std::option::Option<WebServiceDetailsAutoscalingCriteriaMemory>,
7928 }
7929
7930 impl ::std::default::Default for WebServiceDetailsAutoscalingCriteria {
7931 fn default() -> Self {
7932 Self {
7933 cpu: Default::default(),
7934 memory: Default::default(),
7935 }
7936 }
7937 }
7938
7939 ///`WebServiceDetailsAutoscalingCriteriaCpu`
7940 ///
7941 /// <details><summary>JSON schema</summary>
7942 ///
7943 /// ```json
7944 ///{
7945 /// "type": "object",
7946 /// "properties": {
7947 /// "enabled": {
7948 /// "default": false,
7949 /// "type": "boolean"
7950 /// },
7951 /// "percentage": {
7952 /// "description": "Determines when your service will be scaled. If the
7953 /// average resource utilization is significantly above/below the target, we
7954 /// will increase/decrease the number of instances.\n",
7955 /// "type": "integer"
7956 /// }
7957 /// }
7958 ///}
7959 /// ```
7960 /// </details>
7961 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
7962 pub struct WebServiceDetailsAutoscalingCriteriaCpu {
7963 #[serde(default)]
7964 pub enabled: bool,
7965 ///Determines when your service will be scaled. If the average resource
7966 /// utilization is significantly above/below the target, we will
7967 /// increase/decrease the number of instances.
7968 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
7969 pub percentage: ::std::option::Option<i64>,
7970 }
7971
7972 impl ::std::default::Default for WebServiceDetailsAutoscalingCriteriaCpu {
7973 fn default() -> Self {
7974 Self {
7975 enabled: Default::default(),
7976 percentage: Default::default(),
7977 }
7978 }
7979 }
7980
7981 ///`WebServiceDetailsAutoscalingCriteriaMemory`
7982 ///
7983 /// <details><summary>JSON schema</summary>
7984 ///
7985 /// ```json
7986 ///{
7987 /// "type": "object",
7988 /// "properties": {
7989 /// "enabled": {
7990 /// "default": false,
7991 /// "type": "boolean"
7992 /// },
7993 /// "percentage": {
7994 /// "description": "Determines when your service will be scaled. If the
7995 /// average resource utilization is significantly above/below the target, we
7996 /// will increase/decrease the number of instances.\n",
7997 /// "type": "integer"
7998 /// }
7999 /// }
8000 ///}
8001 /// ```
8002 /// </details>
8003 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8004 pub struct WebServiceDetailsAutoscalingCriteriaMemory {
8005 #[serde(default)]
8006 pub enabled: bool,
8007 ///Determines when your service will be scaled. If the average resource
8008 /// utilization is significantly above/below the target, we will
8009 /// increase/decrease the number of instances.
8010 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8011 pub percentage: ::std::option::Option<i64>,
8012 }
8013
8014 impl ::std::default::Default for WebServiceDetailsAutoscalingCriteriaMemory {
8015 fn default() -> Self {
8016 Self {
8017 enabled: Default::default(),
8018 percentage: Default::default(),
8019 }
8020 }
8021 }
8022
8023 ///`WebServiceDetailsDisk`
8024 ///
8025 /// <details><summary>JSON schema</summary>
8026 ///
8027 /// ```json
8028 ///{
8029 /// "type": "object",
8030 /// "properties": {
8031 /// "id": {
8032 /// "examples": [
8033 /// "dsk-cph1rs3idesc73a2b2mg"
8034 /// ],
8035 /// "type": "string",
8036 /// "pattern": "^dsk-[0-9a-z]{20}$"
8037 /// },
8038 /// "mountPath": {
8039 /// "type": "string"
8040 /// },
8041 /// "name": {
8042 /// "type": "string"
8043 /// },
8044 /// "sizeGB": {
8045 /// "type": "integer"
8046 /// }
8047 /// }
8048 ///}
8049 /// ```
8050 /// </details>
8051 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8052 pub struct WebServiceDetailsDisk {
8053 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8054 pub id: ::std::option::Option<WebServiceDetailsDiskId>,
8055 #[serde(
8056 rename = "mountPath",
8057 default,
8058 skip_serializing_if = "::std::option::Option::is_none"
8059 )]
8060 pub mount_path: ::std::option::Option<::std::string::String>,
8061 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8062 pub name: ::std::option::Option<::std::string::String>,
8063 #[serde(
8064 rename = "sizeGB",
8065 default,
8066 skip_serializing_if = "::std::option::Option::is_none"
8067 )]
8068 pub size_gb: ::std::option::Option<i64>,
8069 }
8070
8071 impl ::std::default::Default for WebServiceDetailsDisk {
8072 fn default() -> Self {
8073 Self {
8074 id: Default::default(),
8075 mount_path: Default::default(),
8076 name: Default::default(),
8077 size_gb: Default::default(),
8078 }
8079 }
8080 }
8081
8082 ///`WebServiceDetailsDiskId`
8083 ///
8084 /// <details><summary>JSON schema</summary>
8085 ///
8086 /// ```json
8087 ///{
8088 /// "examples": [
8089 /// "dsk-cph1rs3idesc73a2b2mg"
8090 /// ],
8091 /// "type": "string",
8092 /// "pattern": "^dsk-[0-9a-z]{20}$"
8093 ///}
8094 /// ```
8095 /// </details>
8096 #[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
8097 #[serde(transparent)]
8098 pub struct WebServiceDetailsDiskId(::std::string::String);
8099 impl ::std::ops::Deref for WebServiceDetailsDiskId {
8100 type Target = ::std::string::String;
8101 fn deref(&self) -> &::std::string::String {
8102 &self.0
8103 }
8104 }
8105
8106 impl ::std::convert::From<WebServiceDetailsDiskId> for ::std::string::String {
8107 fn from(value: WebServiceDetailsDiskId) -> Self {
8108 value.0
8109 }
8110 }
8111
8112 impl ::std::str::FromStr for WebServiceDetailsDiskId {
8113 type Err = self::error::ConversionError;
8114 fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
8115 static PATTERN: ::std::sync::LazyLock<::regress::Regex> =
8116 ::std::sync::LazyLock::new(|| ::regress::Regex::new("^dsk-[0-9a-z]{20}$").unwrap());
8117 if PATTERN.find(value).is_none() {
8118 return Err("doesn't match pattern \"^dsk-[0-9a-z]{20}$\"".into());
8119 }
8120 Ok(Self(value.to_string()))
8121 }
8122 }
8123
8124 impl ::std::convert::TryFrom<&str> for WebServiceDetailsDiskId {
8125 type Error = self::error::ConversionError;
8126 fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
8127 value.parse()
8128 }
8129 }
8130
8131 impl ::std::convert::TryFrom<&::std::string::String> for WebServiceDetailsDiskId {
8132 type Error = self::error::ConversionError;
8133 fn try_from(
8134 value: &::std::string::String,
8135 ) -> ::std::result::Result<Self, self::error::ConversionError> {
8136 value.parse()
8137 }
8138 }
8139
8140 impl ::std::convert::TryFrom<::std::string::String> for WebServiceDetailsDiskId {
8141 type Error = self::error::ConversionError;
8142 fn try_from(
8143 value: ::std::string::String,
8144 ) -> ::std::result::Result<Self, self::error::ConversionError> {
8145 value.parse()
8146 }
8147 }
8148
8149 impl<'de> ::serde::Deserialize<'de> for WebServiceDetailsDiskId {
8150 fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
8151 where
8152 D: ::serde::Deserializer<'de>,
8153 {
8154 ::std::string::String::deserialize(deserializer)?
8155 .parse()
8156 .map_err(|e: self::error::ConversionError| {
8157 <D::Error as ::serde::de::Error>::custom(e.to_string())
8158 })
8159 }
8160 }
8161
8162 ///`WebServiceDetailsPost`
8163 ///
8164 /// <details><summary>JSON schema</summary>
8165 ///
8166 /// ```json
8167 ///{
8168 /// "type": "object",
8169 /// "properties": {
8170 /// "autoscaling": {
8171 /// "type": "object",
8172 /// "properties": {
8173 /// "criteria": {
8174 /// "type": "object",
8175 /// "properties": {
8176 /// "cpu": {
8177 /// "type": "object",
8178 /// "properties": {
8179 /// "enabled": {
8180 /// "default": false,
8181 /// "type": "boolean"
8182 /// },
8183 /// "percentage": {
8184 /// "description": "Determines when your service will be
8185 /// scaled. If the average resource utilization is significantly above/below
8186 /// the target, we will increase/decrease the number of instances.\n",
8187 /// "type": "integer"
8188 /// }
8189 /// }
8190 /// },
8191 /// "memory": {
8192 /// "type": "object",
8193 /// "properties": {
8194 /// "enabled": {
8195 /// "default": false,
8196 /// "type": "boolean"
8197 /// },
8198 /// "percentage": {
8199 /// "description": "Determines when your service will be
8200 /// scaled. If the average resource utilization is significantly above/below
8201 /// the target, we will increase/decrease the number of instances.\n",
8202 /// "type": "integer"
8203 /// }
8204 /// }
8205 /// }
8206 /// }
8207 /// },
8208 /// "enabled": {
8209 /// "default": false,
8210 /// "type": "boolean"
8211 /// },
8212 /// "max": {
8213 /// "description": "The maximum number of instances for the
8214 /// service",
8215 /// "type": "integer"
8216 /// },
8217 /// "min": {
8218 /// "description": "The minimum number of instances for the
8219 /// service",
8220 /// "type": "integer"
8221 /// }
8222 /// }
8223 /// },
8224 /// "disk": {
8225 /// "$ref": "#/components/schemas/serviceDisk"
8226 /// },
8227 /// "env": {
8228 /// "$ref": "#/components/schemas/serviceEnv"
8229 /// },
8230 /// "envSpecificDetails": {
8231 /// "$ref": "#/components/schemas/envSpecificDetailsPOST"
8232 /// },
8233 /// "healthCheckPath": {
8234 /// "type": "string"
8235 /// },
8236 /// "ipAllowList": {
8237 /// "type": "array",
8238 /// "items": {
8239 /// "$ref": "#/components/schemas/cidrBlockAndDescription"
8240 /// }
8241 /// },
8242 /// "maintenanceMode": {
8243 /// "$ref": "#/components/schemas/maintenanceMode"
8244 /// },
8245 /// "maxShutdownDelaySeconds": {
8246 /// "$ref": "#/components/schemas/maxShutdownDelaySeconds"
8247 /// },
8248 /// "numInstances": {
8249 /// "description": "Defaults to 1",
8250 /// "type": "integer",
8251 /// "minimum": 1.0
8252 /// },
8253 /// "plan": {
8254 /// "$ref": "#/components/schemas/plan"
8255 /// },
8256 /// "preDeployCommand": {
8257 /// "type": "string"
8258 /// },
8259 /// "previews": {
8260 /// "$ref": "#/components/schemas/previews"
8261 /// },
8262 /// "pullRequestPreviewsEnabled": {
8263 /// "$ref": "#/components/schemas/pullRequestPreviewsEnabled"
8264 /// },
8265 /// "region": {
8266 /// "$ref": "#/components/schemas/region"
8267 /// },
8268 /// "renderSubdomainPolicy": {
8269 /// "$ref": "#/components/schemas/renderSubdomainPolicy"
8270 /// },
8271 /// "runtime": {
8272 /// "$ref": "#/components/schemas/serviceRuntime"
8273 /// }
8274 /// }
8275 ///}
8276 /// ```
8277 /// </details>
8278 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8279 pub struct WebServiceDetailsPost {
8280 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8281 pub autoscaling: ::std::option::Option<WebServiceDetailsPostAutoscaling>,
8282 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8283 pub disk: ::std::option::Option<ServiceDisk>,
8284 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8285 pub env: ::std::option::Option<ServiceEnv>,
8286 #[serde(
8287 rename = "envSpecificDetails",
8288 default,
8289 skip_serializing_if = "::std::option::Option::is_none"
8290 )]
8291 pub env_specific_details: ::std::option::Option<EnvSpecificDetailsPost>,
8292 #[serde(
8293 rename = "healthCheckPath",
8294 default,
8295 skip_serializing_if = "::std::option::Option::is_none"
8296 )]
8297 pub health_check_path: ::std::option::Option<::std::string::String>,
8298 #[serde(
8299 rename = "ipAllowList",
8300 default,
8301 skip_serializing_if = "::std::vec::Vec::is_empty"
8302 )]
8303 pub ip_allow_list: ::std::vec::Vec<CidrBlockAndDescription>,
8304 #[serde(
8305 rename = "maintenanceMode",
8306 default,
8307 skip_serializing_if = "::std::option::Option::is_none"
8308 )]
8309 pub maintenance_mode: ::std::option::Option<MaintenanceMode>,
8310 #[serde(
8311 rename = "maxShutdownDelaySeconds",
8312 default,
8313 skip_serializing_if = "::std::option::Option::is_none"
8314 )]
8315 pub max_shutdown_delay_seconds: ::std::option::Option<MaxShutdownDelaySeconds>,
8316 ///Defaults to 1
8317 #[serde(
8318 rename = "numInstances",
8319 default,
8320 skip_serializing_if = "::std::option::Option::is_none"
8321 )]
8322 pub num_instances: ::std::option::Option<::std::num::NonZeroU64>,
8323 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8324 pub plan: ::std::option::Option<Plan>,
8325 #[serde(
8326 rename = "preDeployCommand",
8327 default,
8328 skip_serializing_if = "::std::option::Option::is_none"
8329 )]
8330 pub pre_deploy_command: ::std::option::Option<::std::string::String>,
8331 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8332 pub previews: ::std::option::Option<Previews>,
8333 #[serde(
8334 rename = "pullRequestPreviewsEnabled",
8335 default,
8336 skip_serializing_if = "::std::option::Option::is_none"
8337 )]
8338 pub pull_request_previews_enabled: ::std::option::Option<PullRequestPreviewsEnabled>,
8339 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8340 pub region: ::std::option::Option<Region>,
8341 #[serde(
8342 rename = "renderSubdomainPolicy",
8343 default,
8344 skip_serializing_if = "::std::option::Option::is_none"
8345 )]
8346 pub render_subdomain_policy: ::std::option::Option<RenderSubdomainPolicy>,
8347 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8348 pub runtime: ::std::option::Option<ServiceRuntime>,
8349 }
8350
8351 impl ::std::default::Default for WebServiceDetailsPost {
8352 fn default() -> Self {
8353 Self {
8354 autoscaling: Default::default(),
8355 disk: Default::default(),
8356 env: Default::default(),
8357 env_specific_details: Default::default(),
8358 health_check_path: Default::default(),
8359 ip_allow_list: Default::default(),
8360 maintenance_mode: Default::default(),
8361 max_shutdown_delay_seconds: Default::default(),
8362 num_instances: Default::default(),
8363 plan: Default::default(),
8364 pre_deploy_command: Default::default(),
8365 previews: Default::default(),
8366 pull_request_previews_enabled: Default::default(),
8367 region: Default::default(),
8368 render_subdomain_policy: Default::default(),
8369 runtime: Default::default(),
8370 }
8371 }
8372 }
8373
8374 ///`WebServiceDetailsPostAutoscaling`
8375 ///
8376 /// <details><summary>JSON schema</summary>
8377 ///
8378 /// ```json
8379 ///{
8380 /// "type": "object",
8381 /// "properties": {
8382 /// "criteria": {
8383 /// "type": "object",
8384 /// "properties": {
8385 /// "cpu": {
8386 /// "type": "object",
8387 /// "properties": {
8388 /// "enabled": {
8389 /// "default": false,
8390 /// "type": "boolean"
8391 /// },
8392 /// "percentage": {
8393 /// "description": "Determines when your service will be
8394 /// scaled. If the average resource utilization is significantly above/below
8395 /// the target, we will increase/decrease the number of instances.\n",
8396 /// "type": "integer"
8397 /// }
8398 /// }
8399 /// },
8400 /// "memory": {
8401 /// "type": "object",
8402 /// "properties": {
8403 /// "enabled": {
8404 /// "default": false,
8405 /// "type": "boolean"
8406 /// },
8407 /// "percentage": {
8408 /// "description": "Determines when your service will be
8409 /// scaled. If the average resource utilization is significantly above/below
8410 /// the target, we will increase/decrease the number of instances.\n",
8411 /// "type": "integer"
8412 /// }
8413 /// }
8414 /// }
8415 /// }
8416 /// },
8417 /// "enabled": {
8418 /// "default": false,
8419 /// "type": "boolean"
8420 /// },
8421 /// "max": {
8422 /// "description": "The maximum number of instances for the service",
8423 /// "type": "integer"
8424 /// },
8425 /// "min": {
8426 /// "description": "The minimum number of instances for the service",
8427 /// "type": "integer"
8428 /// }
8429 /// }
8430 ///}
8431 /// ```
8432 /// </details>
8433 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8434 pub struct WebServiceDetailsPostAutoscaling {
8435 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8436 pub criteria: ::std::option::Option<WebServiceDetailsPostAutoscalingCriteria>,
8437 #[serde(default)]
8438 pub enabled: bool,
8439 ///The maximum number of instances for the service
8440 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8441 pub max: ::std::option::Option<i64>,
8442 ///The minimum number of instances for the service
8443 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8444 pub min: ::std::option::Option<i64>,
8445 }
8446
8447 impl ::std::default::Default for WebServiceDetailsPostAutoscaling {
8448 fn default() -> Self {
8449 Self {
8450 criteria: Default::default(),
8451 enabled: Default::default(),
8452 max: Default::default(),
8453 min: Default::default(),
8454 }
8455 }
8456 }
8457
8458 ///`WebServiceDetailsPostAutoscalingCriteria`
8459 ///
8460 /// <details><summary>JSON schema</summary>
8461 ///
8462 /// ```json
8463 ///{
8464 /// "type": "object",
8465 /// "properties": {
8466 /// "cpu": {
8467 /// "type": "object",
8468 /// "properties": {
8469 /// "enabled": {
8470 /// "default": false,
8471 /// "type": "boolean"
8472 /// },
8473 /// "percentage": {
8474 /// "description": "Determines when your service will be scaled. If
8475 /// the average resource utilization is significantly above/below the
8476 /// target, we will increase/decrease the number of instances.\n",
8477 /// "type": "integer"
8478 /// }
8479 /// }
8480 /// },
8481 /// "memory": {
8482 /// "type": "object",
8483 /// "properties": {
8484 /// "enabled": {
8485 /// "default": false,
8486 /// "type": "boolean"
8487 /// },
8488 /// "percentage": {
8489 /// "description": "Determines when your service will be scaled. If
8490 /// the average resource utilization is significantly above/below the
8491 /// target, we will increase/decrease the number of instances.\n",
8492 /// "type": "integer"
8493 /// }
8494 /// }
8495 /// }
8496 /// }
8497 ///}
8498 /// ```
8499 /// </details>
8500 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8501 pub struct WebServiceDetailsPostAutoscalingCriteria {
8502 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8503 pub cpu: ::std::option::Option<WebServiceDetailsPostAutoscalingCriteriaCpu>,
8504 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8505 pub memory: ::std::option::Option<WebServiceDetailsPostAutoscalingCriteriaMemory>,
8506 }
8507
8508 impl ::std::default::Default for WebServiceDetailsPostAutoscalingCriteria {
8509 fn default() -> Self {
8510 Self {
8511 cpu: Default::default(),
8512 memory: Default::default(),
8513 }
8514 }
8515 }
8516
8517 ///`WebServiceDetailsPostAutoscalingCriteriaCpu`
8518 ///
8519 /// <details><summary>JSON schema</summary>
8520 ///
8521 /// ```json
8522 ///{
8523 /// "type": "object",
8524 /// "properties": {
8525 /// "enabled": {
8526 /// "default": false,
8527 /// "type": "boolean"
8528 /// },
8529 /// "percentage": {
8530 /// "description": "Determines when your service will be scaled. If the
8531 /// average resource utilization is significantly above/below the target, we
8532 /// will increase/decrease the number of instances.\n",
8533 /// "type": "integer"
8534 /// }
8535 /// }
8536 ///}
8537 /// ```
8538 /// </details>
8539 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8540 pub struct WebServiceDetailsPostAutoscalingCriteriaCpu {
8541 #[serde(default)]
8542 pub enabled: bool,
8543 ///Determines when your service will be scaled. If the average resource
8544 /// utilization is significantly above/below the target, we will
8545 /// increase/decrease the number of instances.
8546 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8547 pub percentage: ::std::option::Option<i64>,
8548 }
8549
8550 impl ::std::default::Default for WebServiceDetailsPostAutoscalingCriteriaCpu {
8551 fn default() -> Self {
8552 Self {
8553 enabled: Default::default(),
8554 percentage: Default::default(),
8555 }
8556 }
8557 }
8558
8559 ///`WebServiceDetailsPostAutoscalingCriteriaMemory`
8560 ///
8561 /// <details><summary>JSON schema</summary>
8562 ///
8563 /// ```json
8564 ///{
8565 /// "type": "object",
8566 /// "properties": {
8567 /// "enabled": {
8568 /// "default": false,
8569 /// "type": "boolean"
8570 /// },
8571 /// "percentage": {
8572 /// "description": "Determines when your service will be scaled. If the
8573 /// average resource utilization is significantly above/below the target, we
8574 /// will increase/decrease the number of instances.\n",
8575 /// "type": "integer"
8576 /// }
8577 /// }
8578 ///}
8579 /// ```
8580 /// </details>
8581 #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
8582 pub struct WebServiceDetailsPostAutoscalingCriteriaMemory {
8583 #[serde(default)]
8584 pub enabled: bool,
8585 ///Determines when your service will be scaled. If the average resource
8586 /// utilization is significantly above/below the target, we will
8587 /// increase/decrease the number of instances.
8588 #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
8589 pub percentage: ::std::option::Option<i64>,
8590 }
8591
8592 impl ::std::default::Default for WebServiceDetailsPostAutoscalingCriteriaMemory {
8593 fn default() -> Self {
8594 Self {
8595 enabled: Default::default(),
8596 percentage: Default::default(),
8597 }
8598 }
8599 }
8600
8601 /// Generation of default values for serde.
8602 pub mod defaults {
8603 pub(super) fn default_nzu64<T, const V: u64>() -> T
8604 where
8605 T: ::std::convert::TryFrom<::std::num::NonZeroU64>,
8606 <T as ::std::convert::TryFrom<::std::num::NonZeroU64>>::Error: ::std::fmt::Debug,
8607 {
8608 T::try_from(::std::num::NonZeroU64::try_from(V).unwrap()).unwrap()
8609 }
8610
8611 pub(super) fn cache_profile() -> ::std::string::String {
8612 "no-cache".to_string()
8613 }
8614
8615 pub(super) fn create_deploy_body_clear_cache() -> ::std::string::String {
8616 "do_not_clear".to_string()
8617 }
8618
8619 pub(super) fn postgres_post_input_database_name() -> ::std::string::String {
8620 "randomly generated".to_string()
8621 }
8622
8623 pub(super) fn postgres_post_input_database_user() -> ::std::string::String {
8624 "randomly generated".to_string()
8625 }
8626
8627 pub(super) fn previews_generation() -> ::std::string::String {
8628 "off".to_string()
8629 }
8630 }
8631}
8632
8633#[derive(Clone, Debug)]
8634///Client for Render Public API
8635///
8636///Manage everything about your Render services
8637///
8638///Version: 1.0.0
8639pub struct Client {
8640 pub(crate) baseurl: String,
8641 pub(crate) client: reqwest::Client,
8642}
8643
8644impl Client {
8645 /// Create a new client.
8646 ///
8647 /// `baseurl` is the base URL provided to the internal
8648 /// `reqwest::Client`, and should include a scheme and hostname,
8649 /// as well as port and a path stem if applicable.
8650 pub fn new(baseurl: &str) -> Self {
8651 #[cfg(not(target_arch = "wasm32"))]
8652 let client = {
8653 let dur = ::std::time::Duration::from_secs(15u64);
8654 reqwest::ClientBuilder::new()
8655 .connect_timeout(dur)
8656 .timeout(dur)
8657 };
8658 #[cfg(target_arch = "wasm32")]
8659 let client = reqwest::ClientBuilder::new();
8660 Self::new_with_client(baseurl, client.build().unwrap())
8661 }
8662
8663 /// Construct a new client with an existing `reqwest::Client`,
8664 /// allowing more control over its configuration.
8665 ///
8666 /// `baseurl` is the base URL provided to the internal
8667 /// `reqwest::Client`, and should include a scheme and hostname,
8668 /// as well as port and a path stem if applicable.
8669 pub fn new_with_client(baseurl: &str, client: reqwest::Client) -> Self {
8670 Self {
8671 baseurl: baseurl.to_string(),
8672 client,
8673 }
8674 }
8675}
8676
8677impl ClientInfo<()> for Client {
8678 fn api_version() -> &'static str {
8679 "1.0.0"
8680 }
8681
8682 fn baseurl(&self) -> &str {
8683 self.baseurl.as_str()
8684 }
8685
8686 fn client(&self) -> &reqwest::Client {
8687 &self.client
8688 }
8689
8690 fn inner(&self) -> &() {
8691 &()
8692 }
8693}
8694
8695impl ClientHooks<()> for &Client {}
8696#[allow(clippy::all)]
8697impl Client {
8698 ///List services
8699 ///
8700 ///List services matching the provided filters. If no filters are provided,
8701 /// returns all services you have permissions to view.
8702 ///
8703 ///
8704 ///Sends a `GET` request to `/services`
8705 ///
8706 ///Arguments:
8707 /// - `created_after`: Filter for resources created after a certain time
8708 /// (specified as an ISO 8601 timestamp)
8709 /// - `created_before`: Filter for resources created before a certain time
8710 /// (specified as an ISO 8601 timestamp)
8711 /// - `cursor`: The position in the result list to start from when fetching paginated results. For details, see [Pagination](https://api-docs.render.com/reference/pagination).
8712 /// - `env`: Filter for environments (runtimes) of services (deprecated; use
8713 /// `runtime` instead)
8714 /// - `environment_id`: Filter for resources that belong to an environment
8715 /// - `include_previews`: Include previews in the response
8716 /// - `limit`: The maximum number of items to return. For details, see [Pagination](https://api-docs.render.com/reference/pagination).
8717 /// - `name`: Filter by name
8718 /// - `owner_id`: The ID of the workspaces to return resources for
8719 /// - `region`: Filter by resource region
8720 /// - `suspended`: Filter resources based on whether they're suspended or
8721 /// not suspended
8722 /// - `type_`: Filter for types of services
8723 /// - `updated_after`: Filter for resources updated after a certain time
8724 /// (specified as an ISO 8601 timestamp)
8725 /// - `updated_before`: Filter for resources updated before a certain time
8726 /// (specified as an ISO 8601 timestamp)
8727 pub async fn list_services<'a>(
8728 &'a self,
8729 created_after: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
8730 created_before: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
8731 cursor: Option<&'a str>,
8732 env: Option<&'a ::std::vec::Vec<types::ServiceRuntime>>,
8733 environment_id: Option<&'a ::std::vec::Vec<::std::string::String>>,
8734 include_previews: Option<bool>,
8735 limit: Option<::std::num::NonZeroU64>,
8736 name: Option<&'a ::std::vec::Vec<::std::string::String>>,
8737 owner_id: Option<&'a ::std::vec::Vec<::std::string::String>>,
8738 region: Option<&'a ::std::vec::Vec<types::Region>>,
8739 suspended: Option<&'a ::std::vec::Vec<::std::string::String>>,
8740 type_: Option<&'a ::std::vec::Vec<types::ServiceType>>,
8741 updated_after: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
8742 updated_before: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
8743 ) -> Result<ResponseValue<types::ServiceList>, Error<types::Error>> {
8744 let url = format!("{}/services", self.baseurl,);
8745 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8746 header_map.append(
8747 ::reqwest::header::HeaderName::from_static("api-version"),
8748 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8749 );
8750 #[allow(unused_mut)]
8751 let mut request = self
8752 .client
8753 .get(url)
8754 .header(
8755 ::reqwest::header::ACCEPT,
8756 ::reqwest::header::HeaderValue::from_static("application/json"),
8757 )
8758 .query(&progenitor_client::QueryParam::new(
8759 "createdAfter",
8760 &created_after,
8761 ))
8762 .query(&progenitor_client::QueryParam::new(
8763 "createdBefore",
8764 &created_before,
8765 ))
8766 .query(&progenitor_client::QueryParam::new("cursor", &cursor))
8767 .query(&progenitor_client::QueryParam::new("env", &env))
8768 .query(&progenitor_client::QueryParam::new(
8769 "environmentId",
8770 &environment_id,
8771 ))
8772 .query(&progenitor_client::QueryParam::new(
8773 "includePreviews",
8774 &include_previews,
8775 ))
8776 .query(&progenitor_client::QueryParam::new("limit", &limit))
8777 .query(&progenitor_client::QueryParam::new("name", &name))
8778 .query(&progenitor_client::QueryParam::new("ownerId", &owner_id))
8779 .query(&progenitor_client::QueryParam::new("region", ®ion))
8780 .query(&progenitor_client::QueryParam::new("suspended", &suspended))
8781 .query(&progenitor_client::QueryParam::new("type", &type_))
8782 .query(&progenitor_client::QueryParam::new(
8783 "updatedAfter",
8784 &updated_after,
8785 ))
8786 .query(&progenitor_client::QueryParam::new(
8787 "updatedBefore",
8788 &updated_before,
8789 ))
8790 .headers(header_map)
8791 .build()?;
8792 let info = OperationInfo {
8793 operation_id: "list_services",
8794 };
8795 self.pre(&mut request, &info).await?;
8796 let result = self.exec(request, &info).await;
8797 self.post(&result, &info).await?;
8798 let response = result?;
8799 match response.status().as_u16() {
8800 200u16 => ResponseValue::from_response(response).await,
8801 401u16 => Err(Error::ErrorResponse(
8802 ResponseValue::from_response(response).await?,
8803 )),
8804 406u16 => Err(Error::ErrorResponse(
8805 ResponseValue::from_response(response).await?,
8806 )),
8807 429u16 => Err(Error::ErrorResponse(
8808 ResponseValue::from_response(response).await?,
8809 )),
8810 500u16 => Err(Error::ErrorResponse(
8811 ResponseValue::from_response(response).await?,
8812 )),
8813 503u16 => Err(Error::ErrorResponse(
8814 ResponseValue::from_response(response).await?,
8815 )),
8816 _ => Err(Error::UnexpectedResponse(response)),
8817 }
8818 }
8819
8820 ///Create service
8821 ///
8822 ///Creates a new Render service in the specified workspace with the
8823 /// specified configuration.
8824 ///
8825 ///
8826 ///Sends a `POST` request to `/services`
8827 pub async fn create_service<'a>(
8828 &'a self,
8829 body: &'a types::ServicePost,
8830 ) -> Result<ResponseValue<types::ServiceAndDeploy>, Error<types::Error>> {
8831 let url = format!("{}/services", self.baseurl,);
8832 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8833 header_map.append(
8834 ::reqwest::header::HeaderName::from_static("api-version"),
8835 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8836 );
8837 #[allow(unused_mut)]
8838 let mut request = self
8839 .client
8840 .post(url)
8841 .header(
8842 ::reqwest::header::ACCEPT,
8843 ::reqwest::header::HeaderValue::from_static("application/json"),
8844 )
8845 .json(&body)
8846 .headers(header_map)
8847 .build()?;
8848 let info = OperationInfo {
8849 operation_id: "create_service",
8850 };
8851 self.pre(&mut request, &info).await?;
8852 let result = self.exec(request, &info).await;
8853 self.post(&result, &info).await?;
8854 let response = result?;
8855 match response.status().as_u16() {
8856 201u16 => ResponseValue::from_response(response).await,
8857 400u16 => Err(Error::ErrorResponse(
8858 ResponseValue::from_response(response).await?,
8859 )),
8860 401u16 => Err(Error::ErrorResponse(
8861 ResponseValue::from_response(response).await?,
8862 )),
8863 402u16 => Err(Error::ErrorResponse(
8864 ResponseValue::from_response(response).await?,
8865 )),
8866 404u16 => Err(Error::ErrorResponse(
8867 ResponseValue::from_response(response).await?,
8868 )),
8869 406u16 => Err(Error::ErrorResponse(
8870 ResponseValue::from_response(response).await?,
8871 )),
8872 409u16 => Err(Error::ErrorResponse(
8873 ResponseValue::from_response(response).await?,
8874 )),
8875 429u16 => Err(Error::ErrorResponse(
8876 ResponseValue::from_response(response).await?,
8877 )),
8878 500u16 => Err(Error::ErrorResponse(
8879 ResponseValue::from_response(response).await?,
8880 )),
8881 503u16 => Err(Error::ErrorResponse(
8882 ResponseValue::from_response(response).await?,
8883 )),
8884 _ => Err(Error::UnexpectedResponse(response)),
8885 }
8886 }
8887
8888 ///List Postgres instances
8889 ///
8890 ///List Postgres instances matching the provided filters. If no filters are
8891 /// provided, all Postgres instances are returned.
8892 ///
8893 ///
8894 ///Sends a `GET` request to `/postgres`
8895 ///
8896 ///Arguments:
8897 /// - `created_after`: Filter for resources created after a certain time
8898 /// (specified as an ISO 8601 timestamp)
8899 /// - `created_before`: Filter for resources created before a certain time
8900 /// (specified as an ISO 8601 timestamp)
8901 /// - `cursor`: The position in the result list to start from when fetching paginated results. For details, see [Pagination](https://api-docs.render.com/reference/pagination).
8902 /// - `environment_id`: Filter for resources that belong to an environment
8903 /// - `include_replicas`: Include replicas in the response
8904 /// - `limit`: The maximum number of items to return. For details, see [Pagination](https://api-docs.render.com/reference/pagination).
8905 /// - `name`: Filter by name
8906 /// - `owner_id`: The ID of the workspaces to return resources for
8907 /// - `region`: Filter by resource region
8908 /// - `suspended`: Filter resources based on whether they're suspended or
8909 /// not suspended
8910 /// - `updated_after`: Filter for resources updated after a certain time
8911 /// (specified as an ISO 8601 timestamp)
8912 /// - `updated_before`: Filter for resources updated before a certain time
8913 /// (specified as an ISO 8601 timestamp)
8914 pub async fn list_postgres<'a>(
8915 &'a self,
8916 created_after: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
8917 created_before: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
8918 cursor: Option<&'a str>,
8919 environment_id: Option<&'a ::std::vec::Vec<::std::string::String>>,
8920 include_replicas: Option<bool>,
8921 limit: Option<::std::num::NonZeroU64>,
8922 name: Option<&'a ::std::vec::Vec<::std::string::String>>,
8923 owner_id: Option<&'a ::std::vec::Vec<::std::string::String>>,
8924 region: Option<&'a ::std::vec::Vec<types::Region>>,
8925 suspended: Option<&'a ::std::vec::Vec<::std::string::String>>,
8926 updated_after: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
8927 updated_before: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
8928 ) -> Result<ResponseValue<::std::vec::Vec<types::PostgresWithCursor>>, Error<types::Error>>
8929 {
8930 let url = format!("{}/postgres", self.baseurl,);
8931 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
8932 header_map.append(
8933 ::reqwest::header::HeaderName::from_static("api-version"),
8934 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
8935 );
8936 #[allow(unused_mut)]
8937 let mut request = self
8938 .client
8939 .get(url)
8940 .header(
8941 ::reqwest::header::ACCEPT,
8942 ::reqwest::header::HeaderValue::from_static("application/json"),
8943 )
8944 .query(&progenitor_client::QueryParam::new(
8945 "createdAfter",
8946 &created_after,
8947 ))
8948 .query(&progenitor_client::QueryParam::new(
8949 "createdBefore",
8950 &created_before,
8951 ))
8952 .query(&progenitor_client::QueryParam::new("cursor", &cursor))
8953 .query(&progenitor_client::QueryParam::new(
8954 "environmentId",
8955 &environment_id,
8956 ))
8957 .query(&progenitor_client::QueryParam::new(
8958 "includeReplicas",
8959 &include_replicas,
8960 ))
8961 .query(&progenitor_client::QueryParam::new("limit", &limit))
8962 .query(&progenitor_client::QueryParam::new("name", &name))
8963 .query(&progenitor_client::QueryParam::new("ownerId", &owner_id))
8964 .query(&progenitor_client::QueryParam::new("region", ®ion))
8965 .query(&progenitor_client::QueryParam::new("suspended", &suspended))
8966 .query(&progenitor_client::QueryParam::new(
8967 "updatedAfter",
8968 &updated_after,
8969 ))
8970 .query(&progenitor_client::QueryParam::new(
8971 "updatedBefore",
8972 &updated_before,
8973 ))
8974 .headers(header_map)
8975 .build()?;
8976 let info = OperationInfo {
8977 operation_id: "list_postgres",
8978 };
8979 self.pre(&mut request, &info).await?;
8980 let result = self.exec(request, &info).await;
8981 self.post(&result, &info).await?;
8982 let response = result?;
8983 match response.status().as_u16() {
8984 200u16 => ResponseValue::from_response(response).await,
8985 400u16 => Err(Error::ErrorResponse(
8986 ResponseValue::from_response(response).await?,
8987 )),
8988 401u16 => Err(Error::ErrorResponse(
8989 ResponseValue::from_response(response).await?,
8990 )),
8991 404u16 => Err(Error::ErrorResponse(
8992 ResponseValue::from_response(response).await?,
8993 )),
8994 409u16 => Err(Error::ErrorResponse(
8995 ResponseValue::from_response(response).await?,
8996 )),
8997 429u16 => Err(Error::ErrorResponse(
8998 ResponseValue::from_response(response).await?,
8999 )),
9000 500u16 => Err(Error::ErrorResponse(
9001 ResponseValue::from_response(response).await?,
9002 )),
9003 503u16 => Err(Error::ErrorResponse(
9004 ResponseValue::from_response(response).await?,
9005 )),
9006 _ => Err(Error::UnexpectedResponse(response)),
9007 }
9008 }
9009
9010 ///Create Postgres instance
9011 ///
9012 ///Create a new Postgres instance.
9013 ///
9014 ///
9015 ///Sends a `POST` request to `/postgres`
9016 pub async fn create_postgres<'a>(
9017 &'a self,
9018 body: &'a types::PostgresPostInput,
9019 ) -> Result<ResponseValue<types::PostgresDetail>, Error<types::Error>> {
9020 let url = format!("{}/postgres", self.baseurl,);
9021 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9022 header_map.append(
9023 ::reqwest::header::HeaderName::from_static("api-version"),
9024 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9025 );
9026 #[allow(unused_mut)]
9027 let mut request = self
9028 .client
9029 .post(url)
9030 .header(
9031 ::reqwest::header::ACCEPT,
9032 ::reqwest::header::HeaderValue::from_static("application/json"),
9033 )
9034 .json(&body)
9035 .headers(header_map)
9036 .build()?;
9037 let info = OperationInfo {
9038 operation_id: "create_postgres",
9039 };
9040 self.pre(&mut request, &info).await?;
9041 let result = self.exec(request, &info).await;
9042 self.post(&result, &info).await?;
9043 let response = result?;
9044 match response.status().as_u16() {
9045 201u16 => ResponseValue::from_response(response).await,
9046 400u16 => Err(Error::ErrorResponse(
9047 ResponseValue::from_response(response).await?,
9048 )),
9049 401u16 => Err(Error::ErrorResponse(
9050 ResponseValue::from_response(response).await?,
9051 )),
9052 404u16 => Err(Error::ErrorResponse(
9053 ResponseValue::from_response(response).await?,
9054 )),
9055 429u16 => Err(Error::ErrorResponse(
9056 ResponseValue::from_response(response).await?,
9057 )),
9058 500u16 => Err(Error::ErrorResponse(
9059 ResponseValue::from_response(response).await?,
9060 )),
9061 503u16 => Err(Error::ErrorResponse(
9062 ResponseValue::from_response(response).await?,
9063 )),
9064 _ => Err(Error::UnexpectedResponse(response)),
9065 }
9066 }
9067
9068 ///Retrieve Postgres connection info
9069 ///
9070 ///Retrieve connection info for a Postgres instance by ID. Connection info
9071 /// includes sensitive information.
9072 ///
9073 ///
9074 ///Sends a `GET` request to `/postgres/{postgresId}/connection-info`
9075 pub async fn retrieve_postgres_connection_info<'a>(
9076 &'a self,
9077 postgres_id: &'a str,
9078 ) -> Result<ResponseValue<types::PostgresConnectionInfo>, Error<types::Error>> {
9079 let url = format!(
9080 "{}/postgres/{}/connection-info",
9081 self.baseurl,
9082 encode_path(&postgres_id.to_string()),
9083 );
9084 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9085 header_map.append(
9086 ::reqwest::header::HeaderName::from_static("api-version"),
9087 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9088 );
9089 #[allow(unused_mut)]
9090 let mut request = self
9091 .client
9092 .get(url)
9093 .header(
9094 ::reqwest::header::ACCEPT,
9095 ::reqwest::header::HeaderValue::from_static("application/json"),
9096 )
9097 .headers(header_map)
9098 .build()?;
9099 let info = OperationInfo {
9100 operation_id: "retrieve_postgres_connection_info",
9101 };
9102 self.pre(&mut request, &info).await?;
9103 let result = self.exec(request, &info).await;
9104 self.post(&result, &info).await?;
9105 let response = result?;
9106 match response.status().as_u16() {
9107 200u16 => ResponseValue::from_response(response).await,
9108 400u16 => Err(Error::ErrorResponse(
9109 ResponseValue::from_response(response).await?,
9110 )),
9111 401u16 => Err(Error::ErrorResponse(
9112 ResponseValue::from_response(response).await?,
9113 )),
9114 404u16 => Err(Error::ErrorResponse(
9115 ResponseValue::from_response(response).await?,
9116 )),
9117 429u16 => Err(Error::ErrorResponse(
9118 ResponseValue::from_response(response).await?,
9119 )),
9120 500u16 => Err(Error::ErrorResponse(
9121 ResponseValue::from_response(response).await?,
9122 )),
9123 503u16 => Err(Error::ErrorResponse(
9124 ResponseValue::from_response(response).await?,
9125 )),
9126 _ => Err(Error::UnexpectedResponse(response)),
9127 }
9128 }
9129
9130 ///List environment variables
9131 ///
9132 ///List all environment variables for the service with the provided ID.
9133 ///
9134 ///
9135 ///Sends a `GET` request to `/services/{serviceId}/env-vars`
9136 ///
9137 ///Arguments:
9138 /// - `service_id`: The ID of the service
9139 /// - `cursor`: The position in the result list to start from when fetching paginated results. For details, see [Pagination](https://api-docs.render.com/reference/pagination).
9140 /// - `limit`: The maximum number of items to return. For details, see [Pagination](https://api-docs.render.com/reference/pagination).
9141 pub async fn get_env_vars_for_service<'a>(
9142 &'a self,
9143 service_id: &'a str,
9144 cursor: Option<&'a str>,
9145 limit: Option<::std::num::NonZeroU64>,
9146 ) -> Result<ResponseValue<::std::vec::Vec<types::EnvVarWithCursor>>, Error<types::Error>> {
9147 let url = format!(
9148 "{}/services/{}/env-vars",
9149 self.baseurl,
9150 encode_path(&service_id.to_string()),
9151 );
9152 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9153 header_map.append(
9154 ::reqwest::header::HeaderName::from_static("api-version"),
9155 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9156 );
9157 #[allow(unused_mut)]
9158 let mut request = self
9159 .client
9160 .get(url)
9161 .header(
9162 ::reqwest::header::ACCEPT,
9163 ::reqwest::header::HeaderValue::from_static("application/json"),
9164 )
9165 .query(&progenitor_client::QueryParam::new("cursor", &cursor))
9166 .query(&progenitor_client::QueryParam::new("limit", &limit))
9167 .headers(header_map)
9168 .build()?;
9169 let info = OperationInfo {
9170 operation_id: "get_env_vars_for_service",
9171 };
9172 self.pre(&mut request, &info).await?;
9173 let result = self.exec(request, &info).await;
9174 self.post(&result, &info).await?;
9175 let response = result?;
9176 match response.status().as_u16() {
9177 200u16 => ResponseValue::from_response(response).await,
9178 401u16 => Err(Error::ErrorResponse(
9179 ResponseValue::from_response(response).await?,
9180 )),
9181 403u16 => Err(Error::ErrorResponse(
9182 ResponseValue::from_response(response).await?,
9183 )),
9184 404u16 => Err(Error::ErrorResponse(
9185 ResponseValue::from_response(response).await?,
9186 )),
9187 406u16 => Err(Error::ErrorResponse(
9188 ResponseValue::from_response(response).await?,
9189 )),
9190 410u16 => Err(Error::ErrorResponse(
9191 ResponseValue::from_response(response).await?,
9192 )),
9193 429u16 => Err(Error::ErrorResponse(
9194 ResponseValue::from_response(response).await?,
9195 )),
9196 500u16 => Err(Error::ErrorResponse(
9197 ResponseValue::from_response(response).await?,
9198 )),
9199 503u16 => Err(Error::ErrorResponse(
9200 ResponseValue::from_response(response).await?,
9201 )),
9202 _ => Err(Error::UnexpectedResponse(response)),
9203 }
9204 }
9205
9206 ///Update environment variables
9207 ///
9208 ///Replace all environment variables for a service with the provided list
9209 /// of environment variables.
9210 ///
9211 ///Sends a `PUT` request to `/services/{serviceId}/env-vars`
9212 ///
9213 ///Arguments:
9214 /// - `service_id`: The ID of the service
9215 /// - `body`
9216 pub async fn update_env_vars_for_service<'a>(
9217 &'a self,
9218 service_id: &'a str,
9219 body: &'a ::std::vec::Vec<types::UpdateEnvVarsForServiceBodyItem>,
9220 ) -> Result<ResponseValue<::std::vec::Vec<types::EnvVarWithCursor>>, Error<types::Error>> {
9221 let url = format!(
9222 "{}/services/{}/env-vars",
9223 self.baseurl,
9224 encode_path(&service_id.to_string()),
9225 );
9226 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9227 header_map.append(
9228 ::reqwest::header::HeaderName::from_static("api-version"),
9229 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9230 );
9231 #[allow(unused_mut)]
9232 let mut request = self
9233 .client
9234 .put(url)
9235 .header(
9236 ::reqwest::header::ACCEPT,
9237 ::reqwest::header::HeaderValue::from_static("application/json"),
9238 )
9239 .json(&body)
9240 .headers(header_map)
9241 .build()?;
9242 let info = OperationInfo {
9243 operation_id: "update_env_vars_for_service",
9244 };
9245 self.pre(&mut request, &info).await?;
9246 let result = self.exec(request, &info).await;
9247 self.post(&result, &info).await?;
9248 let response = result?;
9249 match response.status().as_u16() {
9250 200u16 => ResponseValue::from_response(response).await,
9251 400u16 => Err(Error::ErrorResponse(
9252 ResponseValue::from_response(response).await?,
9253 )),
9254 401u16 => Err(Error::ErrorResponse(
9255 ResponseValue::from_response(response).await?,
9256 )),
9257 403u16 => Err(Error::ErrorResponse(
9258 ResponseValue::from_response(response).await?,
9259 )),
9260 404u16 => Err(Error::ErrorResponse(
9261 ResponseValue::from_response(response).await?,
9262 )),
9263 406u16 => Err(Error::ErrorResponse(
9264 ResponseValue::from_response(response).await?,
9265 )),
9266 410u16 => Err(Error::ErrorResponse(
9267 ResponseValue::from_response(response).await?,
9268 )),
9269 429u16 => Err(Error::ErrorResponse(
9270 ResponseValue::from_response(response).await?,
9271 )),
9272 500u16 => Err(Error::ErrorResponse(
9273 ResponseValue::from_response(response).await?,
9274 )),
9275 503u16 => Err(Error::ErrorResponse(
9276 ResponseValue::from_response(response).await?,
9277 )),
9278 _ => Err(Error::UnexpectedResponse(response)),
9279 }
9280 }
9281
9282 ///List redirect/rewrite rules
9283 ///
9284 ///List a particular service's redirect/rewrite rules that match the
9285 /// provided filters. If no filters are provided, all rules for the service
9286 /// are returned.
9287 ///
9288 ///
9289 ///Sends a `GET` request to `/services/{serviceId}/routes`
9290 ///
9291 ///Arguments:
9292 /// - `service_id`: The ID of the service
9293 /// - `cursor`: The position in the result list to start from when fetching paginated results. For details, see [Pagination](https://api-docs.render.com/reference/pagination).
9294 /// - `destination`: Filter for the destination path of the route
9295 /// - `limit`: The maximum number of items to return. For details, see [Pagination](https://api-docs.render.com/reference/pagination).
9296 /// - `source`: Filter for the source path of the route
9297 /// - `type_`: Filter for the type of route rule
9298 pub async fn list_routes<'a>(
9299 &'a self,
9300 service_id: &'a str,
9301 cursor: Option<&'a str>,
9302 destination: Option<&'a ::std::vec::Vec<::std::string::String>>,
9303 limit: Option<::std::num::NonZeroU64>,
9304 source: Option<&'a ::std::vec::Vec<::std::string::String>>,
9305 type_: Option<&'a ::std::vec::Vec<::std::string::String>>,
9306 ) -> Result<ResponseValue<::std::vec::Vec<types::RouteWithCursor>>, Error<types::Error>> {
9307 let url = format!(
9308 "{}/services/{}/routes",
9309 self.baseurl,
9310 encode_path(&service_id.to_string()),
9311 );
9312 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9313 header_map.append(
9314 ::reqwest::header::HeaderName::from_static("api-version"),
9315 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9316 );
9317 #[allow(unused_mut)]
9318 let mut request = self
9319 .client
9320 .get(url)
9321 .header(
9322 ::reqwest::header::ACCEPT,
9323 ::reqwest::header::HeaderValue::from_static("application/json"),
9324 )
9325 .query(&progenitor_client::QueryParam::new("cursor", &cursor))
9326 .query(&progenitor_client::QueryParam::new(
9327 "destination",
9328 &destination,
9329 ))
9330 .query(&progenitor_client::QueryParam::new("limit", &limit))
9331 .query(&progenitor_client::QueryParam::new("source", &source))
9332 .query(&progenitor_client::QueryParam::new("type", &type_))
9333 .headers(header_map)
9334 .build()?;
9335 let info = OperationInfo {
9336 operation_id: "list_routes",
9337 };
9338 self.pre(&mut request, &info).await?;
9339 let result = self.exec(request, &info).await;
9340 self.post(&result, &info).await?;
9341 let response = result?;
9342 match response.status().as_u16() {
9343 200u16 => ResponseValue::from_response(response).await,
9344 401u16 => Err(Error::ErrorResponse(
9345 ResponseValue::from_response(response).await?,
9346 )),
9347 403u16 => Err(Error::ErrorResponse(
9348 ResponseValue::from_response(response).await?,
9349 )),
9350 404u16 => Err(Error::ErrorResponse(
9351 ResponseValue::from_response(response).await?,
9352 )),
9353 406u16 => Err(Error::ErrorResponse(
9354 ResponseValue::from_response(response).await?,
9355 )),
9356 410u16 => Err(Error::ErrorResponse(
9357 ResponseValue::from_response(response).await?,
9358 )),
9359 429u16 => Err(Error::ErrorResponse(
9360 ResponseValue::from_response(response).await?,
9361 )),
9362 500u16 => Err(Error::ErrorResponse(
9363 ResponseValue::from_response(response).await?,
9364 )),
9365 503u16 => Err(Error::ErrorResponse(
9366 ResponseValue::from_response(response).await?,
9367 )),
9368 _ => Err(Error::UnexpectedResponse(response)),
9369 }
9370 }
9371
9372 ///Update redirect/rewrite rules
9373 ///
9374 ///Replace all redirect/rewrite rules for a particular service with the
9375 /// provided list.
9376 ///
9377 ///**This deletes all existing redirect/rewrite rules for the service that
9378 /// aren't included in the request.**
9379 ///
9380 ///Rule priority is assigned according to list order (the first rule in the
9381 /// list has the highest priority).
9382 ///
9383 ///
9384 ///Sends a `PUT` request to `/services/{serviceId}/routes`
9385 ///
9386 ///Arguments:
9387 /// - `service_id`: The ID of the service
9388 /// - `body`
9389 pub async fn put_routes<'a>(
9390 &'a self,
9391 service_id: &'a str,
9392 body: &'a ::std::vec::Vec<types::RoutePut>,
9393 ) -> Result<ResponseValue<::std::vec::Vec<types::Route>>, Error<types::Error>> {
9394 let url = format!(
9395 "{}/services/{}/routes",
9396 self.baseurl,
9397 encode_path(&service_id.to_string()),
9398 );
9399 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9400 header_map.append(
9401 ::reqwest::header::HeaderName::from_static("api-version"),
9402 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9403 );
9404 #[allow(unused_mut)]
9405 let mut request = self
9406 .client
9407 .put(url)
9408 .header(
9409 ::reqwest::header::ACCEPT,
9410 ::reqwest::header::HeaderValue::from_static("application/json"),
9411 )
9412 .json(&body)
9413 .headers(header_map)
9414 .build()?;
9415 let info = OperationInfo {
9416 operation_id: "put_routes",
9417 };
9418 self.pre(&mut request, &info).await?;
9419 let result = self.exec(request, &info).await;
9420 self.post(&result, &info).await?;
9421 let response = result?;
9422 match response.status().as_u16() {
9423 200u16 => ResponseValue::from_response(response).await,
9424 400u16 => Err(Error::ErrorResponse(
9425 ResponseValue::from_response(response).await?,
9426 )),
9427 401u16 => Err(Error::ErrorResponse(
9428 ResponseValue::from_response(response).await?,
9429 )),
9430 403u16 => Err(Error::ErrorResponse(
9431 ResponseValue::from_response(response).await?,
9432 )),
9433 404u16 => Err(Error::ErrorResponse(
9434 ResponseValue::from_response(response).await?,
9435 )),
9436 406u16 => Err(Error::ErrorResponse(
9437 ResponseValue::from_response(response).await?,
9438 )),
9439 410u16 => Err(Error::ErrorResponse(
9440 ResponseValue::from_response(response).await?,
9441 )),
9442 429u16 => Err(Error::ErrorResponse(
9443 ResponseValue::from_response(response).await?,
9444 )),
9445 500u16 => Err(Error::ErrorResponse(
9446 ResponseValue::from_response(response).await?,
9447 )),
9448 503u16 => Err(Error::ErrorResponse(
9449 ResponseValue::from_response(response).await?,
9450 )),
9451 _ => Err(Error::UnexpectedResponse(response)),
9452 }
9453 }
9454
9455 ///Add redirect/rewrite rules
9456 ///
9457 ///Add redirect/rewrite rules to the service with the provided ID.
9458 ///
9459 ///
9460 ///Sends a `POST` request to `/services/{serviceId}/routes`
9461 ///
9462 ///Arguments:
9463 /// - `service_id`: The ID of the service
9464 /// - `body`
9465 pub async fn add_route<'a>(
9466 &'a self,
9467 service_id: &'a str,
9468 body: &'a types::RoutePost,
9469 ) -> Result<ResponseValue<types::Route>, Error<types::Error>> {
9470 let url = format!(
9471 "{}/services/{}/routes",
9472 self.baseurl,
9473 encode_path(&service_id.to_string()),
9474 );
9475 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9476 header_map.append(
9477 ::reqwest::header::HeaderName::from_static("api-version"),
9478 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9479 );
9480 #[allow(unused_mut)]
9481 let mut request = self
9482 .client
9483 .post(url)
9484 .header(
9485 ::reqwest::header::ACCEPT,
9486 ::reqwest::header::HeaderValue::from_static("application/json"),
9487 )
9488 .json(&body)
9489 .headers(header_map)
9490 .build()?;
9491 let info = OperationInfo {
9492 operation_id: "add_route",
9493 };
9494 self.pre(&mut request, &info).await?;
9495 let result = self.exec(request, &info).await;
9496 self.post(&result, &info).await?;
9497 let response = result?;
9498 match response.status().as_u16() {
9499 201u16 => ResponseValue::from_response(response).await,
9500 400u16 => Err(Error::ErrorResponse(
9501 ResponseValue::from_response(response).await?,
9502 )),
9503 401u16 => Err(Error::ErrorResponse(
9504 ResponseValue::from_response(response).await?,
9505 )),
9506 403u16 => Err(Error::ErrorResponse(
9507 ResponseValue::from_response(response).await?,
9508 )),
9509 404u16 => Err(Error::ErrorResponse(
9510 ResponseValue::from_response(response).await?,
9511 )),
9512 406u16 => Err(Error::ErrorResponse(
9513 ResponseValue::from_response(response).await?,
9514 )),
9515 410u16 => Err(Error::ErrorResponse(
9516 ResponseValue::from_response(response).await?,
9517 )),
9518 429u16 => Err(Error::ErrorResponse(
9519 ResponseValue::from_response(response).await?,
9520 )),
9521 500u16 => Err(Error::ErrorResponse(
9522 ResponseValue::from_response(response).await?,
9523 )),
9524 503u16 => Err(Error::ErrorResponse(
9525 ResponseValue::from_response(response).await?,
9526 )),
9527 _ => Err(Error::UnexpectedResponse(response)),
9528 }
9529 }
9530
9531 ///Update redirect/rewrite rule priority
9532 ///
9533 ///Update the priority for a particular redirect/rewrite rule.
9534 ///
9535 ///To apply redirect/rewrite rules to an incoming request, Render starts
9536 /// from the rule with priority `0` and applies the first encountered rule
9537 /// that matches the request's path (if any).
9538 ///
9539 ///Render increments the priority of other rules by `1` as necessary to
9540 /// make space for the updated rule.
9541 ///
9542 ///
9543 ///Sends a `PATCH` request to `/services/{serviceId}/routes`
9544 ///
9545 ///Arguments:
9546 /// - `service_id`: The ID of the service
9547 /// - `body`
9548 pub async fn patch_route<'a>(
9549 &'a self,
9550 service_id: &'a str,
9551 body: &'a types::RoutePatch,
9552 ) -> Result<ResponseValue<types::PatchRouteResponse>, Error<types::Error>> {
9553 let url = format!(
9554 "{}/services/{}/routes",
9555 self.baseurl,
9556 encode_path(&service_id.to_string()),
9557 );
9558 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9559 header_map.append(
9560 ::reqwest::header::HeaderName::from_static("api-version"),
9561 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9562 );
9563 #[allow(unused_mut)]
9564 let mut request = self
9565 .client
9566 .patch(url)
9567 .header(
9568 ::reqwest::header::ACCEPT,
9569 ::reqwest::header::HeaderValue::from_static("application/json"),
9570 )
9571 .json(&body)
9572 .headers(header_map)
9573 .build()?;
9574 let info = OperationInfo {
9575 operation_id: "patch_route",
9576 };
9577 self.pre(&mut request, &info).await?;
9578 let result = self.exec(request, &info).await;
9579 self.post(&result, &info).await?;
9580 let response = result?;
9581 match response.status().as_u16() {
9582 200u16 => ResponseValue::from_response(response).await,
9583 401u16 => Err(Error::ErrorResponse(
9584 ResponseValue::from_response(response).await?,
9585 )),
9586 403u16 => Err(Error::ErrorResponse(
9587 ResponseValue::from_response(response).await?,
9588 )),
9589 404u16 => Err(Error::ErrorResponse(
9590 ResponseValue::from_response(response).await?,
9591 )),
9592 406u16 => Err(Error::ErrorResponse(
9593 ResponseValue::from_response(response).await?,
9594 )),
9595 410u16 => Err(Error::ErrorResponse(
9596 ResponseValue::from_response(response).await?,
9597 )),
9598 429u16 => Err(Error::ErrorResponse(
9599 ResponseValue::from_response(response).await?,
9600 )),
9601 500u16 => Err(Error::ErrorResponse(
9602 ResponseValue::from_response(response).await?,
9603 )),
9604 503u16 => Err(Error::ErrorResponse(
9605 ResponseValue::from_response(response).await?,
9606 )),
9607 _ => Err(Error::UnexpectedResponse(response)),
9608 }
9609 }
9610
9611 ///List deploys
9612 ///
9613 ///List deploys matching the provided filters. If no filters are provided,
9614 /// all deploys for the service are returned.
9615 ///
9616 ///
9617 ///Sends a `GET` request to `/services/{serviceId}/deploys`
9618 ///
9619 ///Arguments:
9620 /// - `service_id`: The ID of the service
9621 /// - `created_after`: Filter for deploys created after a certain time
9622 /// (specified as an ISO 8601 timestamp)
9623 /// - `created_before`: Filter for deploys created before a certain time
9624 /// (specified as an ISO 8601 timestamp)
9625 /// - `cursor`: The position in the result list to start from when fetching paginated results. For details, see [Pagination](https://api-docs.render.com/reference/pagination).
9626 /// - `finished_after`: Filter for deploys finished after a certain time
9627 /// (specified as an ISO 8601 timestamp)
9628 /// - `finished_before`: Filter for deploys finished before a certain time
9629 /// (specified as an ISO 8601 timestamp)
9630 /// - `limit`: The maximum number of items to return. For details, see [Pagination](https://api-docs.render.com/reference/pagination).
9631 /// - `status`: Filter for deploys with the specified statuses
9632 /// - `updated_after`: Filter for deploys updated after a certain time
9633 /// (specified as an ISO 8601 timestamp)
9634 /// - `updated_before`: Filter for deploys updated before a certain time
9635 /// (specified as an ISO 8601 timestamp)
9636 pub async fn list_deploys<'a>(
9637 &'a self,
9638 service_id: &'a str,
9639 created_after: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
9640 created_before: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
9641 cursor: Option<&'a str>,
9642 finished_after: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
9643 finished_before: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
9644 limit: Option<::std::num::NonZeroU64>,
9645 status: Option<&'a ::std::vec::Vec<types::DeployStatus>>,
9646 updated_after: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
9647 updated_before: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
9648 ) -> Result<ResponseValue<types::DeployList>, Error<types::Error>> {
9649 let url = format!(
9650 "{}/services/{}/deploys",
9651 self.baseurl,
9652 encode_path(&service_id.to_string()),
9653 );
9654 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9655 header_map.append(
9656 ::reqwest::header::HeaderName::from_static("api-version"),
9657 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9658 );
9659 #[allow(unused_mut)]
9660 let mut request = self
9661 .client
9662 .get(url)
9663 .header(
9664 ::reqwest::header::ACCEPT,
9665 ::reqwest::header::HeaderValue::from_static("application/json"),
9666 )
9667 .query(&progenitor_client::QueryParam::new(
9668 "createdAfter",
9669 &created_after,
9670 ))
9671 .query(&progenitor_client::QueryParam::new(
9672 "createdBefore",
9673 &created_before,
9674 ))
9675 .query(&progenitor_client::QueryParam::new("cursor", &cursor))
9676 .query(&progenitor_client::QueryParam::new(
9677 "finishedAfter",
9678 &finished_after,
9679 ))
9680 .query(&progenitor_client::QueryParam::new(
9681 "finishedBefore",
9682 &finished_before,
9683 ))
9684 .query(&progenitor_client::QueryParam::new("limit", &limit))
9685 .query(&progenitor_client::QueryParam::new("status", &status))
9686 .query(&progenitor_client::QueryParam::new(
9687 "updatedAfter",
9688 &updated_after,
9689 ))
9690 .query(&progenitor_client::QueryParam::new(
9691 "updatedBefore",
9692 &updated_before,
9693 ))
9694 .headers(header_map)
9695 .build()?;
9696 let info = OperationInfo {
9697 operation_id: "list_deploys",
9698 };
9699 self.pre(&mut request, &info).await?;
9700 let result = self.exec(request, &info).await;
9701 self.post(&result, &info).await?;
9702 let response = result?;
9703 match response.status().as_u16() {
9704 200u16 => ResponseValue::from_response(response).await,
9705 401u16 => Err(Error::ErrorResponse(
9706 ResponseValue::from_response(response).await?,
9707 )),
9708 403u16 => Err(Error::ErrorResponse(
9709 ResponseValue::from_response(response).await?,
9710 )),
9711 404u16 => Err(Error::ErrorResponse(
9712 ResponseValue::from_response(response).await?,
9713 )),
9714 406u16 => Err(Error::ErrorResponse(
9715 ResponseValue::from_response(response).await?,
9716 )),
9717 410u16 => Err(Error::ErrorResponse(
9718 ResponseValue::from_response(response).await?,
9719 )),
9720 429u16 => Err(Error::ErrorResponse(
9721 ResponseValue::from_response(response).await?,
9722 )),
9723 500u16 => Err(Error::ErrorResponse(
9724 ResponseValue::from_response(response).await?,
9725 )),
9726 503u16 => Err(Error::ErrorResponse(
9727 ResponseValue::from_response(response).await?,
9728 )),
9729 _ => Err(Error::UnexpectedResponse(response)),
9730 }
9731 }
9732
9733 ///Trigger deploy
9734 ///
9735 ///Trigger a deploy for the service with the provided ID.
9736 ///
9737 ///
9738 ///Sends a `POST` request to `/services/{serviceId}/deploys`
9739 ///
9740 ///Arguments:
9741 /// - `service_id`: The ID of the service
9742 /// - `body`
9743 pub async fn create_deploy<'a>(
9744 &'a self,
9745 service_id: &'a str,
9746 body: &'a types::CreateDeployBody,
9747 ) -> Result<ResponseValue<()>, Error<types::Error>> {
9748 let url = format!(
9749 "{}/services/{}/deploys",
9750 self.baseurl,
9751 encode_path(&service_id.to_string()),
9752 );
9753 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9754 header_map.append(
9755 ::reqwest::header::HeaderName::from_static("api-version"),
9756 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9757 );
9758 #[allow(unused_mut)]
9759 let mut request = self
9760 .client
9761 .post(url)
9762 .header(
9763 ::reqwest::header::ACCEPT,
9764 ::reqwest::header::HeaderValue::from_static("application/json"),
9765 )
9766 .json(&body)
9767 .headers(header_map)
9768 .build()?;
9769 let info = OperationInfo {
9770 operation_id: "create_deploy",
9771 };
9772 self.pre(&mut request, &info).await?;
9773 let result = self.exec(request, &info).await;
9774 self.post(&result, &info).await?;
9775 let response = result?;
9776 match response.status().as_u16() {
9777 202u16 => Ok(ResponseValue::empty(response)),
9778 400u16 => Err(Error::ErrorResponse(
9779 ResponseValue::from_response(response).await?,
9780 )),
9781 401u16 => Err(Error::ErrorResponse(
9782 ResponseValue::from_response(response).await?,
9783 )),
9784 404u16 => Err(Error::ErrorResponse(
9785 ResponseValue::from_response(response).await?,
9786 )),
9787 406u16 => Err(Error::ErrorResponse(
9788 ResponseValue::from_response(response).await?,
9789 )),
9790 409u16 => Err(Error::ErrorResponse(
9791 ResponseValue::from_response(response).await?,
9792 )),
9793 410u16 => Err(Error::ErrorResponse(
9794 ResponseValue::from_response(response).await?,
9795 )),
9796 429u16 => Err(Error::ErrorResponse(
9797 ResponseValue::from_response(response).await?,
9798 )),
9799 500u16 => Err(Error::ErrorResponse(
9800 ResponseValue::from_response(response).await?,
9801 )),
9802 503u16 => Err(Error::ErrorResponse(
9803 ResponseValue::from_response(response).await?,
9804 )),
9805 _ => Err(Error::UnexpectedResponse(response)),
9806 }
9807 }
9808
9809 ///Retrieve deploy
9810 ///
9811 ///Retrieve the details of a particular deploy for a particular service.
9812 ///
9813 ///
9814 ///Sends a `GET` request to `/services/{serviceId}/deploys/{deployId}`
9815 ///
9816 ///Arguments:
9817 /// - `service_id`: The ID of the service
9818 /// - `deploy_id`: The ID of the deploy
9819 pub async fn retrieve_deploy<'a>(
9820 &'a self,
9821 service_id: &'a str,
9822 deploy_id: &'a str,
9823 ) -> Result<ResponseValue<types::Deploy>, Error<types::Error>> {
9824 let url = format!(
9825 "{}/services/{}/deploys/{}",
9826 self.baseurl,
9827 encode_path(&service_id.to_string()),
9828 encode_path(&deploy_id.to_string()),
9829 );
9830 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9831 header_map.append(
9832 ::reqwest::header::HeaderName::from_static("api-version"),
9833 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9834 );
9835 #[allow(unused_mut)]
9836 let mut request = self
9837 .client
9838 .get(url)
9839 .header(
9840 ::reqwest::header::ACCEPT,
9841 ::reqwest::header::HeaderValue::from_static("application/json"),
9842 )
9843 .headers(header_map)
9844 .build()?;
9845 let info = OperationInfo {
9846 operation_id: "retrieve_deploy",
9847 };
9848 self.pre(&mut request, &info).await?;
9849 let result = self.exec(request, &info).await;
9850 self.post(&result, &info).await?;
9851 let response = result?;
9852 match response.status().as_u16() {
9853 200u16 => ResponseValue::from_response(response).await,
9854 401u16 => Err(Error::ErrorResponse(
9855 ResponseValue::from_response(response).await?,
9856 )),
9857 403u16 => Err(Error::ErrorResponse(
9858 ResponseValue::from_response(response).await?,
9859 )),
9860 404u16 => Err(Error::ErrorResponse(
9861 ResponseValue::from_response(response).await?,
9862 )),
9863 406u16 => Err(Error::ErrorResponse(
9864 ResponseValue::from_response(response).await?,
9865 )),
9866 410u16 => Err(Error::ErrorResponse(
9867 ResponseValue::from_response(response).await?,
9868 )),
9869 429u16 => Err(Error::ErrorResponse(
9870 ResponseValue::from_response(response).await?,
9871 )),
9872 500u16 => Err(Error::ErrorResponse(
9873 ResponseValue::from_response(response).await?,
9874 )),
9875 503u16 => Err(Error::ErrorResponse(
9876 ResponseValue::from_response(response).await?,
9877 )),
9878 _ => Err(Error::UnexpectedResponse(response)),
9879 }
9880 }
9881
9882 ///List logs
9883 ///
9884 ///List logs matching the provided filters. Logs are paginated by start and
9885 /// end timestamps. There are more logs to fetch if `hasMore` is true in
9886 /// the response. Provide the `nextStartTime` and `nextEndTime`
9887 /// timestamps as the `startTime` and `endTime` query parameters to fetch
9888 /// the next page of logs.
9889 ///
9890 ///You can query for logs across multiple resources, but all resources must
9891 /// be in the same region and belong to the same owner.
9892 ///
9893 ///
9894 ///Sends a `GET` request to `/logs`
9895 ///
9896 ///Arguments:
9897 /// - `direction`: The direction to query logs for. Backward will return
9898 /// most recent logs first.
9899 ///Forward will start with the oldest logs in the time range.
9900 ///
9901 /// - `end_time`: Epoch/Unix timestamp of end of time range to return.
9902 /// Defaults to `now()`.
9903 /// - `host`: Filter request logs by their host. [Wildcards and regex](https://render.com/docs/logging#wildcards-and-regular-expressions)
9904 /// are supported.
9905 /// - `instance`: Filter logs by the instance they were emitted from. An
9906 /// instance is the id of a specific running server.
9907 /// - `level`: Filter logs by their severity level. [Wildcards and regex](https://render.com/docs/logging#wildcards-and-regular-expressions)
9908 /// are supported.
9909 /// - `limit`: The maximum number of items to return. For details, see [Pagination](https://api-docs.render.com/reference/pagination).
9910 /// - `method`: Filter request logs by their requests method. [Wildcards and
9911 /// regex](https://render.com/docs/logging#wildcards-and-regular-expressions)
9912 /// are supported.
9913 /// - `owner_id`: The ID of the workspace to return logs for
9914 /// - `path`: Filter request logs by their path. [Wildcards and regex](https://render.com/docs/logging#wildcards-and-regular-expressions)
9915 /// are supported.
9916 /// - `resource`: Filter logs by their resource. A resource is the id of a
9917 /// server, cronjob, job, postgres, redis, or workflow.
9918 /// - `start_time`: Epoch/Unix timestamp of start of time range to return.
9919 /// Defaults to `now() - 1 hour`.
9920 /// - `status_code`: Filter request logs by their status code. [Wildcards and regex](https://render.com/docs/logging#wildcards-and-regular-expressions) are supported.
9921 /// - `task`: Filter logs by their task(s)
9922 /// - `task_run`: Filter logs by their task run id(s)
9923 /// - `text`: Filter by the text of the logs. [Wildcards and regex](https://render.com/docs/logging#wildcards-and-regular-expressions)
9924 /// are supported.
9925 /// - `type_`: Filter logs by their type. Types include `app` for
9926 /// application logs, `request` for request logs, and `build` for build
9927 /// logs. You can find the full set of types available for a query by
9928 /// using the `GET /logs/values` endpoint.
9929 pub async fn list_logs<'a>(
9930 &'a self,
9931 direction: Option<&'a str>,
9932 end_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
9933 host: Option<&'a ::std::vec::Vec<::std::string::String>>,
9934 instance: Option<&'a ::std::vec::Vec<::std::string::String>>,
9935 level: Option<&'a ::std::vec::Vec<::std::string::String>>,
9936 limit: Option<::std::num::NonZeroU64>,
9937 method: Option<&'a ::std::vec::Vec<::std::string::String>>,
9938 owner_id: &'a str,
9939 path: Option<&'a ::std::vec::Vec<::std::string::String>>,
9940 resource: &'a ::std::vec::Vec<::std::string::String>,
9941 start_time: Option<&'a ::chrono::DateTime<::chrono::offset::Utc>>,
9942 status_code: Option<&'a ::std::vec::Vec<::std::string::String>>,
9943 task: Option<&'a ::std::vec::Vec<::std::string::String>>,
9944 task_run: Option<&'a ::std::vec::Vec<::std::string::String>>,
9945 text: Option<&'a ::std::vec::Vec<::std::string::String>>,
9946 type_: Option<&'a ::std::vec::Vec<::std::string::String>>,
9947 ) -> Result<ResponseValue<types::ListLogsResponse>, Error<types::Error>> {
9948 let url = format!("{}/logs", self.baseurl,);
9949 let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
9950 header_map.append(
9951 ::reqwest::header::HeaderName::from_static("api-version"),
9952 ::reqwest::header::HeaderValue::from_static(Self::api_version()),
9953 );
9954 #[allow(unused_mut)]
9955 let mut request = self
9956 .client
9957 .get(url)
9958 .header(
9959 ::reqwest::header::ACCEPT,
9960 ::reqwest::header::HeaderValue::from_static("application/json"),
9961 )
9962 .query(&progenitor_client::QueryParam::new("direction", &direction))
9963 .query(&progenitor_client::QueryParam::new("endTime", &end_time))
9964 .query(&progenitor_client::QueryParam::new("host", &host))
9965 .query(&progenitor_client::QueryParam::new("instance", &instance))
9966 .query(&progenitor_client::QueryParam::new("level", &level))
9967 .query(&progenitor_client::QueryParam::new("limit", &limit))
9968 .query(&progenitor_client::QueryParam::new("method", &method))
9969 .query(&progenitor_client::QueryParam::new("ownerId", &owner_id))
9970 .query(&progenitor_client::QueryParam::new("path", &path))
9971 .query(&progenitor_client::QueryParam::new("resource", &resource))
9972 .query(&progenitor_client::QueryParam::new(
9973 "startTime",
9974 &start_time,
9975 ))
9976 .query(&progenitor_client::QueryParam::new(
9977 "statusCode",
9978 &status_code,
9979 ))
9980 .query(&progenitor_client::QueryParam::new("task", &task))
9981 .query(&progenitor_client::QueryParam::new("taskRun", &task_run))
9982 .query(&progenitor_client::QueryParam::new("text", &text))
9983 .query(&progenitor_client::QueryParam::new("type", &type_))
9984 .headers(header_map)
9985 .build()?;
9986 let info = OperationInfo {
9987 operation_id: "list_logs",
9988 };
9989 self.pre(&mut request, &info).await?;
9990 let result = self.exec(request, &info).await;
9991 self.post(&result, &info).await?;
9992 let response = result?;
9993 match response.status().as_u16() {
9994 200u16 => ResponseValue::from_response(response).await,
9995 400u16 => Err(Error::ErrorResponse(
9996 ResponseValue::from_response(response).await?,
9997 )),
9998 401u16 => Err(Error::ErrorResponse(
9999 ResponseValue::from_response(response).await?,
10000 )),
10001 403u16 => Err(Error::ErrorResponse(
10002 ResponseValue::from_response(response).await?,
10003 )),
10004 404u16 => Err(Error::ErrorResponse(
10005 ResponseValue::from_response(response).await?,
10006 )),
10007 406u16 => Err(Error::ErrorResponse(
10008 ResponseValue::from_response(response).await?,
10009 )),
10010 410u16 => Err(Error::ErrorResponse(
10011 ResponseValue::from_response(response).await?,
10012 )),
10013 429u16 => Err(Error::ErrorResponse(
10014 ResponseValue::from_response(response).await?,
10015 )),
10016 500u16 => Err(Error::ErrorResponse(
10017 ResponseValue::from_response(response).await?,
10018 )),
10019 503u16 => Err(Error::ErrorResponse(
10020 ResponseValue::from_response(response).await?,
10021 )),
10022 _ => Err(Error::UnexpectedResponse(response)),
10023 }
10024 }
10025}
10026
10027/// Items consumers will typically use such as the Client.
10028pub mod prelude {
10029 #[allow(unused_imports)]
10030 pub use super::Client;
10031}