1#![allow(non_camel_case_types)]
2#![allow(unused_imports)]
3use serde::de::{value, Deserializer, IntoDeserializer};
4use serde::{Deserialize, Serialize, Serializer};
5use std::str::FromStr;
6#[doc = "Represents an allowed environment type."]
7#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
8pub struct AllowedEnvironmentType {
9 #[serde(flatten)]
10 pub resource: Resource,
11 #[doc = "Properties of an allowed environment type."]
12 #[serde(default, skip_serializing_if = "Option::is_none")]
13 pub properties: Option<AllowedEnvironmentTypeProperties>,
14}
15impl AllowedEnvironmentType {
16 pub fn new() -> Self {
17 Self::default()
18 }
19}
20#[doc = "Result of the allowed environment type list operation."]
21#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
22pub struct AllowedEnvironmentTypeListResult {
23 #[doc = "Current page of results."]
24 #[serde(
25 default,
26 deserialize_with = "azure_core::util::deserialize_null_as_default",
27 skip_serializing_if = "Vec::is_empty"
28 )]
29 pub value: Vec<AllowedEnvironmentType>,
30 #[doc = "URL to get the next set of results if there are any."]
31 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
32 pub next_link: Option<String>,
33}
34impl azure_core::Continuable for AllowedEnvironmentTypeListResult {
35 type Continuation = String;
36 fn continuation(&self) -> Option<Self::Continuation> {
37 self.next_link.clone().filter(|value| !value.is_empty())
38 }
39}
40impl AllowedEnvironmentTypeListResult {
41 pub fn new() -> Self {
42 Self::default()
43 }
44}
45#[doc = "Properties of an allowed environment type."]
46#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
47pub struct AllowedEnvironmentTypeProperties {
48 #[doc = "Provisioning state of the resource."]
49 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
50 pub provisioning_state: Option<ProvisioningState>,
51 #[doc = "The display name of the allowed environment type."]
52 #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
53 pub display_name: Option<String>,
54}
55impl AllowedEnvironmentTypeProperties {
56 pub fn new() -> Self {
57 Self::default()
58 }
59}
60#[doc = "Represents an attached NetworkConnection."]
61#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
62pub struct AttachedNetworkConnection {
63 #[serde(flatten)]
64 pub resource: Resource,
65 #[doc = "Properties of an attached NetworkConnection."]
66 #[serde(default, skip_serializing_if = "Option::is_none")]
67 pub properties: Option<AttachedNetworkConnectionProperties>,
68}
69impl AttachedNetworkConnection {
70 pub fn new() -> Self {
71 Self::default()
72 }
73}
74#[doc = "Properties of an attached NetworkConnection."]
75#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
76pub struct AttachedNetworkConnectionProperties {
77 #[doc = "Provisioning state of the resource."]
78 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
79 pub provisioning_state: Option<ProvisioningState>,
80 #[doc = "The resource ID of the NetworkConnection you want to attach."]
81 #[serde(rename = "networkConnectionId")]
82 pub network_connection_id: String,
83 #[doc = "The geo-location where the NetworkConnection resource specified in 'networkConnectionResourceId' property lives."]
84 #[serde(rename = "networkConnectionLocation", default, skip_serializing_if = "Option::is_none")]
85 pub network_connection_location: Option<String>,
86 #[doc = "Health check status values"]
87 #[serde(rename = "healthCheckStatus", default, skip_serializing_if = "Option::is_none")]
88 pub health_check_status: Option<HealthCheckStatus>,
89 #[doc = "Active Directory join type"]
90 #[serde(rename = "domainJoinType", default, skip_serializing_if = "Option::is_none")]
91 pub domain_join_type: Option<DomainJoinType>,
92}
93impl AttachedNetworkConnectionProperties {
94 pub fn new(network_connection_id: String) -> Self {
95 Self {
96 provisioning_state: None,
97 network_connection_id,
98 network_connection_location: None,
99 health_check_status: None,
100 domain_join_type: None,
101 }
102 }
103}
104#[doc = "Results of the Attached Networks list operation."]
105#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
106pub struct AttachedNetworkListResult {
107 #[doc = "Current page of results."]
108 #[serde(
109 default,
110 deserialize_with = "azure_core::util::deserialize_null_as_default",
111 skip_serializing_if = "Vec::is_empty"
112 )]
113 pub value: Vec<AttachedNetworkConnection>,
114 #[doc = "URL to get the next set of results if there are any."]
115 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
116 pub next_link: Option<String>,
117}
118impl azure_core::Continuable for AttachedNetworkListResult {
119 type Continuation = String;
120 fn continuation(&self) -> Option<Self::Continuation> {
121 self.next_link.clone().filter(|value| !value.is_empty())
122 }
123}
124impl AttachedNetworkListResult {
125 pub fn new() -> Self {
126 Self::default()
127 }
128}
129#[doc = "A name/value pair to describe a capability."]
130#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
131pub struct Capability {
132 #[doc = "Name of the capability."]
133 #[serde(default, skip_serializing_if = "Option::is_none")]
134 pub name: Option<String>,
135 #[doc = "Value of the capability."]
136 #[serde(default, skip_serializing_if = "Option::is_none")]
137 pub value: Option<String>,
138}
139impl Capability {
140 pub fn new() -> Self {
141 Self::default()
142 }
143}
144#[doc = "Represents a catalog."]
145#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
146pub struct Catalog {
147 #[serde(flatten)]
148 pub resource: Resource,
149 #[doc = "Properties of a catalog."]
150 #[serde(default, skip_serializing_if = "Option::is_none")]
151 pub properties: Option<CatalogProperties>,
152}
153impl Catalog {
154 pub fn new() -> Self {
155 Self::default()
156 }
157}
158#[doc = "An individual conflict error."]
159#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
160pub struct CatalogConflictError {
161 #[doc = "The path of the file that has a conflicting name."]
162 #[serde(default, skip_serializing_if = "Option::is_none")]
163 pub path: Option<String>,
164 #[doc = "Name of the conflicting catalog item."]
165 #[serde(default, skip_serializing_if = "Option::is_none")]
166 pub name: Option<String>,
167}
168impl CatalogConflictError {
169 pub fn new() -> Self {
170 Self::default()
171 }
172}
173#[doc = "Catalog error details"]
174#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
175pub struct CatalogErrorDetails {
176 #[doc = "An identifier for the error."]
177 #[serde(default, skip_serializing_if = "Option::is_none")]
178 pub code: Option<String>,
179 #[doc = "A message describing the error."]
180 #[serde(default, skip_serializing_if = "Option::is_none")]
181 pub message: Option<String>,
182}
183impl CatalogErrorDetails {
184 pub fn new() -> Self {
185 Self::default()
186 }
187}
188#[doc = "Catalog item sync types enable or disable status. Indicates whether project catalogs are allowed to sync catalog items under projects associated to this dev center."]
189#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
190#[serde(remote = "CatalogItemSyncEnableStatus")]
191pub enum CatalogItemSyncEnableStatus {
192 Enabled,
193 Disabled,
194 #[serde(skip_deserializing)]
195 UnknownValue(String),
196}
197impl FromStr for CatalogItemSyncEnableStatus {
198 type Err = value::Error;
199 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
200 Self::deserialize(s.into_deserializer())
201 }
202}
203impl<'de> Deserialize<'de> for CatalogItemSyncEnableStatus {
204 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
205 where
206 D: Deserializer<'de>,
207 {
208 let s = String::deserialize(deserializer)?;
209 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
210 Ok(deserialized)
211 }
212}
213impl Serialize for CatalogItemSyncEnableStatus {
214 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
215 where
216 S: Serializer,
217 {
218 match self {
219 Self::Enabled => serializer.serialize_unit_variant("CatalogItemSyncEnableStatus", 0u32, "Enabled"),
220 Self::Disabled => serializer.serialize_unit_variant("CatalogItemSyncEnableStatus", 1u32, "Disabled"),
221 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
222 }
223 }
224}
225#[doc = "Indicates catalog item types."]
226#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
227#[serde(remote = "CatalogItemType")]
228pub enum CatalogItemType {
229 EnvironmentDefinition,
230 ImageDefinition,
231 #[serde(skip_deserializing)]
232 UnknownValue(String),
233}
234impl FromStr for CatalogItemType {
235 type Err = value::Error;
236 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
237 Self::deserialize(s.into_deserializer())
238 }
239}
240impl<'de> Deserialize<'de> for CatalogItemType {
241 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
242 where
243 D: Deserializer<'de>,
244 {
245 let s = String::deserialize(deserializer)?;
246 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
247 Ok(deserialized)
248 }
249}
250impl Serialize for CatalogItemType {
251 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
252 where
253 S: Serializer,
254 {
255 match self {
256 Self::EnvironmentDefinition => serializer.serialize_unit_variant("CatalogItemType", 0u32, "EnvironmentDefinition"),
257 Self::ImageDefinition => serializer.serialize_unit_variant("CatalogItemType", 1u32, "ImageDefinition"),
258 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
259 }
260 }
261}
262#[doc = "Results of the catalog list operation."]
263#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
264pub struct CatalogListResult {
265 #[doc = "Current page of results."]
266 #[serde(
267 default,
268 deserialize_with = "azure_core::util::deserialize_null_as_default",
269 skip_serializing_if = "Vec::is_empty"
270 )]
271 pub value: Vec<Catalog>,
272 #[doc = "URL to get the next set of results if there are any."]
273 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
274 pub next_link: Option<String>,
275}
276impl azure_core::Continuable for CatalogListResult {
277 type Continuation = String;
278 fn continuation(&self) -> Option<Self::Continuation> {
279 self.next_link.clone().filter(|value| !value.is_empty())
280 }
281}
282impl CatalogListResult {
283 pub fn new() -> Self {
284 Self::default()
285 }
286}
287#[doc = "Properties of a catalog."]
288#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
289pub struct CatalogProperties {
290 #[serde(flatten)]
291 pub catalog_update_properties: CatalogUpdateProperties,
292 #[doc = "Provisioning state of the resource."]
293 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
294 pub provisioning_state: Option<ProvisioningState>,
295 #[doc = "The synchronization state of the catalog."]
296 #[serde(rename = "syncState", default, skip_serializing_if = "Option::is_none")]
297 pub sync_state: Option<catalog_properties::SyncState>,
298 #[doc = "Stats of the synchronization."]
299 #[serde(rename = "lastSyncStats", default, skip_serializing_if = "Option::is_none")]
300 pub last_sync_stats: Option<SyncStats>,
301 #[doc = "The connection state of the catalog."]
302 #[serde(rename = "connectionState", default, skip_serializing_if = "Option::is_none")]
303 pub connection_state: Option<catalog_properties::ConnectionState>,
304 #[doc = "When the catalog was last connected."]
305 #[serde(rename = "lastConnectionTime", default, with = "azure_core::date::rfc3339::option")]
306 pub last_connection_time: Option<::time::OffsetDateTime>,
307 #[doc = "When the catalog was last synced."]
308 #[serde(rename = "lastSyncTime", default, with = "azure_core::date::rfc3339::option")]
309 pub last_sync_time: Option<::time::OffsetDateTime>,
310}
311impl CatalogProperties {
312 pub fn new() -> Self {
313 Self::default()
314 }
315}
316pub mod catalog_properties {
317 use super::*;
318 #[doc = "The synchronization state of the catalog."]
319 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
320 #[serde(remote = "SyncState")]
321 pub enum SyncState {
322 Succeeded,
323 InProgress,
324 Failed,
325 Canceled,
326 #[serde(skip_deserializing)]
327 UnknownValue(String),
328 }
329 impl FromStr for SyncState {
330 type Err = value::Error;
331 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
332 Self::deserialize(s.into_deserializer())
333 }
334 }
335 impl<'de> Deserialize<'de> for SyncState {
336 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
337 where
338 D: Deserializer<'de>,
339 {
340 let s = String::deserialize(deserializer)?;
341 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
342 Ok(deserialized)
343 }
344 }
345 impl Serialize for SyncState {
346 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
347 where
348 S: Serializer,
349 {
350 match self {
351 Self::Succeeded => serializer.serialize_unit_variant("SyncState", 0u32, "Succeeded"),
352 Self::InProgress => serializer.serialize_unit_variant("SyncState", 1u32, "InProgress"),
353 Self::Failed => serializer.serialize_unit_variant("SyncState", 2u32, "Failed"),
354 Self::Canceled => serializer.serialize_unit_variant("SyncState", 3u32, "Canceled"),
355 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
356 }
357 }
358 }
359 #[doc = "The connection state of the catalog."]
360 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
361 #[serde(remote = "ConnectionState")]
362 pub enum ConnectionState {
363 Connected,
364 Disconnected,
365 #[serde(skip_deserializing)]
366 UnknownValue(String),
367 }
368 impl FromStr for ConnectionState {
369 type Err = value::Error;
370 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
371 Self::deserialize(s.into_deserializer())
372 }
373 }
374 impl<'de> Deserialize<'de> for ConnectionState {
375 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
376 where
377 D: Deserializer<'de>,
378 {
379 let s = String::deserialize(deserializer)?;
380 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
381 Ok(deserialized)
382 }
383 }
384 impl Serialize for ConnectionState {
385 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
386 where
387 S: Serializer,
388 {
389 match self {
390 Self::Connected => serializer.serialize_unit_variant("ConnectionState", 0u32, "Connected"),
391 Self::Disconnected => serializer.serialize_unit_variant("ConnectionState", 1u32, "Disconnected"),
392 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
393 }
394 }
395 }
396}
397#[doc = "List of validator error details. Populated when changes are made to the resource or its dependent resources that impact the validity of the Catalog resource."]
398#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
399pub struct CatalogResourceValidationErrorDetails {
400 #[doc = "Errors associated with resources synchronized from the catalog."]
401 #[serde(
402 default,
403 deserialize_with = "azure_core::util::deserialize_null_as_default",
404 skip_serializing_if = "Vec::is_empty"
405 )]
406 pub errors: Vec<CatalogErrorDetails>,
407}
408impl CatalogResourceValidationErrorDetails {
409 pub fn new() -> Self {
410 Self::default()
411 }
412}
413#[doc = "Catalog resource validation status"]
414#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
415#[serde(remote = "CatalogResourceValidationStatus")]
416pub enum CatalogResourceValidationStatus {
417 Unknown,
418 Pending,
419 Succeeded,
420 Failed,
421 #[serde(skip_deserializing)]
422 UnknownValue(String),
423}
424impl FromStr for CatalogResourceValidationStatus {
425 type Err = value::Error;
426 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
427 Self::deserialize(s.into_deserializer())
428 }
429}
430impl<'de> Deserialize<'de> for CatalogResourceValidationStatus {
431 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
432 where
433 D: Deserializer<'de>,
434 {
435 let s = String::deserialize(deserializer)?;
436 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
437 Ok(deserialized)
438 }
439}
440impl Serialize for CatalogResourceValidationStatus {
441 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
442 where
443 S: Serializer,
444 {
445 match self {
446 Self::Unknown => serializer.serialize_unit_variant("CatalogResourceValidationStatus", 0u32, "Unknown"),
447 Self::Pending => serializer.serialize_unit_variant("CatalogResourceValidationStatus", 1u32, "Pending"),
448 Self::Succeeded => serializer.serialize_unit_variant("CatalogResourceValidationStatus", 2u32, "Succeeded"),
449 Self::Failed => serializer.serialize_unit_variant("CatalogResourceValidationStatus", 3u32, "Failed"),
450 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
451 }
452 }
453}
454#[doc = "An individual synchronization error."]
455#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
456pub struct CatalogSyncError {
457 #[doc = "The path of the file the error is associated with."]
458 #[serde(default, skip_serializing_if = "Option::is_none")]
459 pub path: Option<String>,
460 #[doc = "Errors associated with the file."]
461 #[serde(
462 rename = "errorDetails",
463 default,
464 deserialize_with = "azure_core::util::deserialize_null_as_default",
465 skip_serializing_if = "Vec::is_empty"
466 )]
467 pub error_details: Vec<CatalogErrorDetails>,
468}
469impl CatalogSyncError {
470 pub fn new() -> Self {
471 Self::default()
472 }
473}
474#[doc = "The catalog's properties for partial update. Properties not provided in the update request will not be changed."]
475#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
476pub struct CatalogUpdate {
477 #[doc = "Properties of a catalog. These properties can be updated after the resource has been created."]
478 #[serde(default, skip_serializing_if = "Option::is_none")]
479 pub properties: Option<CatalogUpdateProperties>,
480}
481impl CatalogUpdate {
482 pub fn new() -> Self {
483 Self::default()
484 }
485}
486#[doc = "Properties of a catalog. These properties can be updated after the resource has been created."]
487#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
488pub struct CatalogUpdateProperties {
489 #[doc = "Properties for a Git repository catalog."]
490 #[serde(rename = "gitHub", default, skip_serializing_if = "Option::is_none")]
491 pub git_hub: Option<GitCatalog>,
492 #[doc = "Properties for a Git repository catalog."]
493 #[serde(rename = "adoGit", default, skip_serializing_if = "Option::is_none")]
494 pub ado_git: Option<GitCatalog>,
495 #[doc = "Indicates the type of sync that is configured for the catalog."]
496 #[serde(rename = "syncType", default, skip_serializing_if = "Option::is_none")]
497 pub sync_type: Option<catalog_update_properties::SyncType>,
498 #[doc = "Resource tags."]
499 #[serde(default, skip_serializing_if = "Option::is_none")]
500 pub tags: Option<serde_json::Value>,
501}
502impl CatalogUpdateProperties {
503 pub fn new() -> Self {
504 Self::default()
505 }
506}
507pub mod catalog_update_properties {
508 use super::*;
509 #[doc = "Indicates the type of sync that is configured for the catalog."]
510 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
511 #[serde(remote = "SyncType")]
512 pub enum SyncType {
513 Manual,
514 Scheduled,
515 #[serde(skip_deserializing)]
516 UnknownValue(String),
517 }
518 impl FromStr for SyncType {
519 type Err = value::Error;
520 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
521 Self::deserialize(s.into_deserializer())
522 }
523 }
524 impl<'de> Deserialize<'de> for SyncType {
525 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
526 where
527 D: Deserializer<'de>,
528 {
529 let s = String::deserialize(deserializer)?;
530 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
531 Ok(deserialized)
532 }
533 }
534 impl Serialize for SyncType {
535 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
536 where
537 S: Serializer,
538 {
539 match self {
540 Self::Manual => serializer.serialize_unit_variant("SyncType", 0u32, "Manual"),
541 Self::Scheduled => serializer.serialize_unit_variant("SyncType", 1u32, "Scheduled"),
542 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
543 }
544 }
545 }
546}
547#[doc = "The check availability request body."]
548#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
549pub struct CheckNameAvailabilityRequest {
550 #[doc = "The name of the resource for which availability needs to be checked."]
551 #[serde(default, skip_serializing_if = "Option::is_none")]
552 pub name: Option<String>,
553 #[doc = "The resource type."]
554 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
555 pub type_: Option<String>,
556}
557impl CheckNameAvailabilityRequest {
558 pub fn new() -> Self {
559 Self::default()
560 }
561}
562#[doc = "The check availability result."]
563#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
564pub struct CheckNameAvailabilityResponse {
565 #[doc = "Indicates if the resource name is available."]
566 #[serde(rename = "nameAvailable", default, skip_serializing_if = "Option::is_none")]
567 pub name_available: Option<bool>,
568 #[doc = "The reason why the given name is not available."]
569 #[serde(default, skip_serializing_if = "Option::is_none")]
570 pub reason: Option<check_name_availability_response::Reason>,
571 #[doc = "Detailed reason why the given name is available."]
572 #[serde(default, skip_serializing_if = "Option::is_none")]
573 pub message: Option<String>,
574}
575impl CheckNameAvailabilityResponse {
576 pub fn new() -> Self {
577 Self::default()
578 }
579}
580pub mod check_name_availability_response {
581 use super::*;
582 #[doc = "The reason why the given name is not available."]
583 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
584 #[serde(remote = "Reason")]
585 pub enum Reason {
586 Invalid,
587 AlreadyExists,
588 #[serde(skip_deserializing)]
589 UnknownValue(String),
590 }
591 impl FromStr for Reason {
592 type Err = value::Error;
593 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
594 Self::deserialize(s.into_deserializer())
595 }
596 }
597 impl<'de> Deserialize<'de> for Reason {
598 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
599 where
600 D: Deserializer<'de>,
601 {
602 let s = String::deserialize(deserializer)?;
603 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
604 Ok(deserialized)
605 }
606 }
607 impl Serialize for Reason {
608 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
609 where
610 S: Serializer,
611 {
612 match self {
613 Self::Invalid => serializer.serialize_unit_variant("Reason", 0u32, "Invalid"),
614 Self::AlreadyExists => serializer.serialize_unit_variant("Reason", 1u32, "AlreadyExists"),
615 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
616 }
617 }
618 }
619}
620#[doc = "The scoped name check availability request body."]
621#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
622pub struct CheckScopedNameAvailabilityRequest {
623 #[doc = "The name of the resource for which availability needs to be checked."]
624 #[serde(default, skip_serializing_if = "Option::is_none")]
625 pub name: Option<String>,
626 #[doc = "The resource type."]
627 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
628 pub type_: Option<String>,
629 #[doc = "The resource id to scope the name check."]
630 #[serde(default, skip_serializing_if = "Option::is_none")]
631 pub scope: Option<String>,
632}
633impl CheckScopedNameAvailabilityRequest {
634 pub fn new() -> Self {
635 Self::default()
636 }
637}
638#[doc = "Represents a Task to be used in customizing a Dev Box."]
639#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
640pub struct CustomizationTask {
641 #[serde(flatten)]
642 pub proxy_resource: ProxyResource,
643 #[doc = "Properties of a Task."]
644 #[serde(default, skip_serializing_if = "Option::is_none")]
645 pub properties: Option<CustomizationTaskProperties>,
646}
647impl CustomizationTask {
648 pub fn new() -> Self {
649 Self::default()
650 }
651}
652#[doc = "Input for a Task."]
653#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
654pub struct CustomizationTaskInput {
655 #[doc = "Description of the input."]
656 #[serde(default, skip_serializing_if = "Option::is_none")]
657 pub description: Option<String>,
658 #[doc = "Type of the input."]
659 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
660 pub type_: Option<customization_task_input::Type>,
661 #[doc = "Whether or not the input is required."]
662 #[serde(default, skip_serializing_if = "Option::is_none")]
663 pub required: Option<bool>,
664}
665impl CustomizationTaskInput {
666 pub fn new() -> Self {
667 Self::default()
668 }
669}
670pub mod customization_task_input {
671 use super::*;
672 #[doc = "Type of the input."]
673 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
674 #[serde(remote = "Type")]
675 pub enum Type {
676 #[serde(rename = "string")]
677 String,
678 #[serde(rename = "number")]
679 Number,
680 #[serde(rename = "boolean")]
681 Boolean,
682 #[serde(skip_deserializing)]
683 UnknownValue(String),
684 }
685 impl FromStr for Type {
686 type Err = value::Error;
687 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
688 Self::deserialize(s.into_deserializer())
689 }
690 }
691 impl<'de> Deserialize<'de> for Type {
692 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
693 where
694 D: Deserializer<'de>,
695 {
696 let s = String::deserialize(deserializer)?;
697 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
698 Ok(deserialized)
699 }
700 }
701 impl Serialize for Type {
702 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
703 where
704 S: Serializer,
705 {
706 match self {
707 Self::String => serializer.serialize_unit_variant("Type", 0u32, "string"),
708 Self::Number => serializer.serialize_unit_variant("Type", 1u32, "number"),
709 Self::Boolean => serializer.serialize_unit_variant("Type", 2u32, "boolean"),
710 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
711 }
712 }
713 }
714}
715#[doc = "Results of the Task list operation."]
716#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
717pub struct CustomizationTaskListResult {
718 #[doc = "Current page of results."]
719 #[serde(
720 default,
721 deserialize_with = "azure_core::util::deserialize_null_as_default",
722 skip_serializing_if = "Vec::is_empty"
723 )]
724 pub value: Vec<CustomizationTask>,
725 #[doc = "URL to get the next set of results if there are any."]
726 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
727 pub next_link: Option<String>,
728}
729impl azure_core::Continuable for CustomizationTaskListResult {
730 type Continuation = String;
731 fn continuation(&self) -> Option<Self::Continuation> {
732 self.next_link.clone().filter(|value| !value.is_empty())
733 }
734}
735impl CustomizationTaskListResult {
736 pub fn new() -> Self {
737 Self::default()
738 }
739}
740#[doc = "Properties of a Task."]
741#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
742pub struct CustomizationTaskProperties {
743 #[doc = "Inputs to the task."]
744 #[serde(default, skip_serializing_if = "Option::is_none")]
745 pub inputs: Option<serde_json::Value>,
746 #[doc = "The default timeout for the task."]
747 #[serde(default, skip_serializing_if = "Option::is_none")]
748 pub timeout: Option<i32>,
749 #[doc = "Catalog resource validation status"]
750 #[serde(rename = "validationStatus", default, skip_serializing_if = "Option::is_none")]
751 pub validation_status: Option<CatalogResourceValidationStatus>,
752}
753impl CustomizationTaskProperties {
754 pub fn new() -> Self {
755 Self::default()
756 }
757}
758#[doc = "Represents a definition for a Developer Machine."]
759#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
760pub struct DevBoxDefinition {
761 #[serde(flatten)]
762 pub tracked_resource: TrackedResource,
763 #[doc = "Properties of a Dev Box definition."]
764 #[serde(default, skip_serializing_if = "Option::is_none")]
765 pub properties: Option<DevBoxDefinitionProperties>,
766}
767impl DevBoxDefinition {
768 pub fn new(tracked_resource: TrackedResource) -> Self {
769 Self {
770 tracked_resource,
771 properties: None,
772 }
773 }
774}
775#[doc = "Results of the Dev Box definition list operation."]
776#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
777pub struct DevBoxDefinitionListResult {
778 #[doc = "Current page of results."]
779 #[serde(
780 default,
781 deserialize_with = "azure_core::util::deserialize_null_as_default",
782 skip_serializing_if = "Vec::is_empty"
783 )]
784 pub value: Vec<DevBoxDefinition>,
785 #[doc = "URL to get the next set of results if there are any."]
786 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
787 pub next_link: Option<String>,
788}
789impl azure_core::Continuable for DevBoxDefinitionListResult {
790 type Continuation = String;
791 fn continuation(&self) -> Option<Self::Continuation> {
792 self.next_link.clone().filter(|value| !value.is_empty())
793 }
794}
795impl DevBoxDefinitionListResult {
796 pub fn new() -> Self {
797 Self::default()
798 }
799}
800#[doc = "Properties of a Dev Box definition."]
801#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
802pub struct DevBoxDefinitionProperties {
803 #[serde(flatten)]
804 pub dev_box_definition_update_properties: DevBoxDefinitionUpdateProperties,
805 #[doc = "Provisioning state of the resource."]
806 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
807 pub provisioning_state: Option<ProvisioningState>,
808 #[doc = "Image validation status"]
809 #[serde(rename = "imageValidationStatus", default, skip_serializing_if = "Option::is_none")]
810 pub image_validation_status: Option<ImageValidationStatus>,
811 #[doc = "Image validation error details"]
812 #[serde(rename = "imageValidationErrorDetails", default, skip_serializing_if = "Option::is_none")]
813 pub image_validation_error_details: Option<ImageValidationErrorDetails>,
814 #[doc = "Catalog resource validation status"]
815 #[serde(rename = "validationStatus", default, skip_serializing_if = "Option::is_none")]
816 pub validation_status: Option<CatalogResourceValidationStatus>,
817 #[doc = "Image reference information"]
818 #[serde(rename = "activeImageReference", default, skip_serializing_if = "Option::is_none")]
819 pub active_image_reference: Option<ImageReference>,
820}
821impl DevBoxDefinitionProperties {
822 pub fn new() -> Self {
823 Self {
824 dev_box_definition_update_properties: DevBoxDefinitionUpdateProperties::default(),
825 provisioning_state: None,
826 image_validation_status: None,
827 image_validation_error_details: None,
828 validation_status: None,
829 active_image_reference: None,
830 }
831 }
832}
833#[doc = "Partial update of a Dev Box definition resource."]
834#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
835pub struct DevBoxDefinitionUpdate {
836 #[serde(flatten)]
837 pub tracked_resource_update: TrackedResourceUpdate,
838 #[doc = "Properties of a Dev Box definition. These properties can be updated after the resource has been created."]
839 #[serde(default, skip_serializing_if = "Option::is_none")]
840 pub properties: Option<DevBoxDefinitionUpdateProperties>,
841}
842impl DevBoxDefinitionUpdate {
843 pub fn new() -> Self {
844 Self::default()
845 }
846}
847#[doc = "Properties of a Dev Box definition. These properties can be updated after the resource has been created."]
848#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
849pub struct DevBoxDefinitionUpdateProperties {
850 #[doc = "Image reference information"]
851 #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
852 pub image_reference: Option<ImageReference>,
853 #[doc = "The resource model definition representing SKU"]
854 #[serde(default, skip_serializing_if = "Option::is_none")]
855 pub sku: Option<Sku>,
856 #[doc = "The storage type used for the Operating System disk of Dev Boxes created using this definition."]
857 #[serde(rename = "osStorageType", default, skip_serializing_if = "Option::is_none")]
858 pub os_storage_type: Option<String>,
859 #[doc = "Indicates whether hibernate is enabled/disabled."]
860 #[serde(rename = "hibernateSupport", default, skip_serializing_if = "Option::is_none")]
861 pub hibernate_support: Option<HibernateSupport>,
862}
863impl DevBoxDefinitionUpdateProperties {
864 pub fn new() -> Self {
865 Self::default()
866 }
867}
868#[doc = "Provisioning settings that apply to all Dev Boxes created in this dev center"]
869#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
870pub struct DevBoxProvisioningSettings {
871 #[doc = "Setting to be used when determining whether to install the Azure Monitor Agent service on Dev Boxes that belong to this dev center."]
872 #[serde(rename = "installAzureMonitorAgentEnableStatus", default, skip_serializing_if = "Option::is_none")]
873 pub install_azure_monitor_agent_enable_status: Option<InstallAzureMonitorAgentEnableStatus>,
874}
875impl DevBoxProvisioningSettings {
876 pub fn new() -> Self {
877 Self::default()
878 }
879}
880#[doc = "Represents a devcenter resource."]
881#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
882pub struct DevCenter {
883 #[serde(flatten)]
884 pub tracked_resource: TrackedResource,
885 #[doc = "Properties of the devcenter."]
886 #[serde(default, skip_serializing_if = "Option::is_none")]
887 pub properties: Option<DevCenterProperties>,
888 #[doc = "Managed service identity (system assigned and/or user assigned identities)"]
889 #[serde(default, skip_serializing_if = "Option::is_none")]
890 pub identity: Option<ManagedServiceIdentity>,
891}
892impl DevCenter {
893 pub fn new(tracked_resource: TrackedResource) -> Self {
894 Self {
895 tracked_resource,
896 properties: None,
897 identity: None,
898 }
899 }
900}
901#[doc = "Represents a devcenter encryption set resource."]
902#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
903pub struct DevCenterEncryptionSet {
904 #[serde(flatten)]
905 pub tracked_resource: TrackedResource,
906 #[doc = "Properties of the devcenter encryption set."]
907 #[serde(default, skip_serializing_if = "Option::is_none")]
908 pub properties: Option<DevCenterEncryptionSetProperties>,
909 #[doc = "Managed service identity (system assigned and/or user assigned identities)"]
910 #[serde(default, skip_serializing_if = "Option::is_none")]
911 pub identity: Option<ManagedServiceIdentity>,
912}
913impl DevCenterEncryptionSet {
914 pub fn new(tracked_resource: TrackedResource) -> Self {
915 Self {
916 tracked_resource,
917 properties: None,
918 identity: None,
919 }
920 }
921}
922#[doc = "Properties of the devcenter encryption set."]
923#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
924pub struct DevCenterEncryptionSetProperties {
925 #[serde(flatten)]
926 pub dev_center_encryption_set_update_properties: DevCenterEncryptionSetUpdateProperties,
927 #[doc = "Provisioning state of the resource."]
928 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
929 pub provisioning_state: Option<ProvisioningState>,
930}
931impl DevCenterEncryptionSetProperties {
932 pub fn new() -> Self {
933 Self::default()
934 }
935}
936#[doc = "Properties of the devcenter encryption set. These properties can be updated after the resource has been created."]
937#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
938pub struct DevCenterEncryptionSetUpdateProperties {
939 #[doc = "Devbox disk encryption enable or disable status. Indicates if Devbox disks encryption is enabled or not."]
940 #[serde(rename = "devboxDisksEncryptionEnableStatus", default, skip_serializing_if = "Option::is_none")]
941 pub devbox_disks_encryption_enable_status: Option<DevboxDisksEncryptionEnableStatus>,
942 #[doc = "Key encryption key Url, versioned or non-versioned. Ex: https://contosovault.vault.azure.net/keys/contosokek/562a4bb76b524a1493a6afe8e536ee78 or https://contosovault.vault.azure.net/keys/contosokek."]
943 #[serde(rename = "keyEncryptionKeyUrl", default, skip_serializing_if = "Option::is_none")]
944 pub key_encryption_key_url: Option<String>,
945}
946impl DevCenterEncryptionSetUpdateProperties {
947 pub fn new() -> Self {
948 Self::default()
949 }
950}
951#[doc = "Result of the list devcenters operation"]
952#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
953pub struct DevCenterListResult {
954 #[doc = "Current page of results."]
955 #[serde(
956 default,
957 deserialize_with = "azure_core::util::deserialize_null_as_default",
958 skip_serializing_if = "Vec::is_empty"
959 )]
960 pub value: Vec<DevCenter>,
961 #[doc = "URL to get the next set of results if there are any."]
962 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
963 pub next_link: Option<String>,
964}
965impl azure_core::Continuable for DevCenterListResult {
966 type Continuation = String;
967 fn continuation(&self) -> Option<Self::Continuation> {
968 self.next_link.clone().filter(|value| !value.is_empty())
969 }
970}
971impl DevCenterListResult {
972 pub fn new() -> Self {
973 Self::default()
974 }
975}
976#[doc = "Network settings for the Dev Center."]
977#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
978pub struct DevCenterNetworkSettings {
979 #[doc = "Indicates whether pools in this Dev Center can use Microsoft Hosted Networks. Defaults to Enabled if not set."]
980 #[serde(rename = "microsoftHostedNetworkEnableStatus", default, skip_serializing_if = "Option::is_none")]
981 pub microsoft_hosted_network_enable_status: Option<MicrosoftHostedNetworkEnableStatus>,
982}
983impl DevCenterNetworkSettings {
984 pub fn new() -> Self {
985 Self::default()
986 }
987}
988#[doc = "Represents a devcenter plan resource."]
989#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
990pub struct DevCenterPlan {
991 #[serde(flatten)]
992 pub tracked_resource: TrackedResource,
993 #[doc = "Properties of the devcenter plan."]
994 #[serde(default, skip_serializing_if = "Option::is_none")]
995 pub properties: Option<PlanProperties>,
996 #[doc = "The resource model definition representing SKU"]
997 #[serde(default, skip_serializing_if = "Option::is_none")]
998 pub sku: Option<Sku>,
999}
1000impl DevCenterPlan {
1001 pub fn new(tracked_resource: TrackedResource) -> Self {
1002 Self {
1003 tracked_resource,
1004 properties: None,
1005 sku: None,
1006 }
1007 }
1008}
1009#[doc = "Represents a devcenter plan member resource."]
1010#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1011pub struct DevCenterPlanMember {
1012 #[serde(flatten)]
1013 pub resource: Resource,
1014 #[doc = "Properties of the devcenter plan member."]
1015 #[serde(default, skip_serializing_if = "Option::is_none")]
1016 pub properties: Option<PlanMemberProperties>,
1017 #[doc = "Resource tags."]
1018 #[serde(default, skip_serializing_if = "Option::is_none")]
1019 pub tags: Option<Tags>,
1020}
1021impl DevCenterPlanMember {
1022 pub fn new() -> Self {
1023 Self::default()
1024 }
1025}
1026#[doc = "Project catalog settings for project catalogs under a project associated to this dev center."]
1027#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1028pub struct DevCenterProjectCatalogSettings {
1029 #[doc = "Catalog item sync types enable or disable status. Indicates whether project catalogs are allowed to sync catalog items under projects associated to this dev center."]
1030 #[serde(rename = "catalogItemSyncEnableStatus", default, skip_serializing_if = "Option::is_none")]
1031 pub catalog_item_sync_enable_status: Option<CatalogItemSyncEnableStatus>,
1032}
1033impl DevCenterProjectCatalogSettings {
1034 pub fn new() -> Self {
1035 Self::default()
1036 }
1037}
1038#[doc = "Properties of the devcenter."]
1039#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1040pub struct DevCenterProperties {
1041 #[serde(flatten)]
1042 pub dev_center_update_properties: DevCenterUpdateProperties,
1043 #[doc = "Provisioning state of the resource."]
1044 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
1045 pub provisioning_state: Option<ProvisioningState>,
1046 #[doc = "The URI of the resource."]
1047 #[serde(rename = "devCenterUri", default, skip_serializing_if = "Option::is_none")]
1048 pub dev_center_uri: Option<DevCenterUri>,
1049}
1050impl DevCenterProperties {
1051 pub fn new() -> Self {
1052 Self::default()
1053 }
1054}
1055#[doc = "The resource model definition representing SKU for DevCenter resources"]
1056#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1057pub struct DevCenterSku {
1058 #[serde(flatten)]
1059 pub sku: Sku,
1060 #[doc = "The name of the resource type"]
1061 #[serde(rename = "resourceType", default, skip_serializing_if = "Option::is_none")]
1062 pub resource_type: Option<String>,
1063 #[doc = "SKU supported locations."]
1064 #[serde(
1065 default,
1066 deserialize_with = "azure_core::util::deserialize_null_as_default",
1067 skip_serializing_if = "Vec::is_empty"
1068 )]
1069 pub locations: Vec<String>,
1070 #[doc = "Collection of name/value pairs to describe the SKU capabilities."]
1071 #[serde(
1072 default,
1073 deserialize_with = "azure_core::util::deserialize_null_as_default",
1074 skip_serializing_if = "Vec::is_empty"
1075 )]
1076 pub capabilities: Vec<Capability>,
1077}
1078impl DevCenterSku {
1079 pub fn new(sku: Sku) -> Self {
1080 Self {
1081 sku,
1082 resource_type: None,
1083 locations: Vec::new(),
1084 capabilities: Vec::new(),
1085 }
1086 }
1087}
1088#[doc = "The devcenter resource for partial updates. Properties not provided in the update request will not be changed."]
1089#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1090pub struct DevCenterUpdate {
1091 #[serde(flatten)]
1092 pub tracked_resource_update: TrackedResourceUpdate,
1093 #[doc = "Managed service identity (system assigned and/or user assigned identities)"]
1094 #[serde(default, skip_serializing_if = "Option::is_none")]
1095 pub identity: Option<ManagedServiceIdentity>,
1096 #[doc = "Properties of the devcenter. These properties can be updated after the resource has been created."]
1097 #[serde(default, skip_serializing_if = "Option::is_none")]
1098 pub properties: Option<DevCenterUpdateProperties>,
1099}
1100impl DevCenterUpdate {
1101 pub fn new() -> Self {
1102 Self::default()
1103 }
1104}
1105#[doc = "Properties of the devcenter. These properties can be updated after the resource has been created."]
1106#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1107pub struct DevCenterUpdateProperties {
1108 #[doc = "Resource Id of an associated Plan"]
1109 #[serde(rename = "planId", default, skip_serializing_if = "Option::is_none")]
1110 pub plan_id: Option<String>,
1111 #[serde(default, skip_serializing_if = "Option::is_none")]
1112 pub encryption: Option<Encryption>,
1113 #[doc = "The display name of the devcenter."]
1114 #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
1115 pub display_name: Option<String>,
1116 #[doc = "Project catalog settings for project catalogs under a project associated to this dev center."]
1117 #[serde(rename = "projectCatalogSettings", default, skip_serializing_if = "Option::is_none")]
1118 pub project_catalog_settings: Option<DevCenterProjectCatalogSettings>,
1119 #[doc = "Network settings for the Dev Center."]
1120 #[serde(rename = "networkSettings", default, skip_serializing_if = "Option::is_none")]
1121 pub network_settings: Option<DevCenterNetworkSettings>,
1122 #[doc = "Provisioning settings that apply to all Dev Boxes created in this dev center"]
1123 #[serde(rename = "devBoxProvisioningSettings", default, skip_serializing_if = "Option::is_none")]
1124 pub dev_box_provisioning_settings: Option<DevBoxProvisioningSettings>,
1125}
1126impl DevCenterUpdateProperties {
1127 pub fn new() -> Self {
1128 Self::default()
1129 }
1130}
1131pub type DevCenterUri = String;
1132#[doc = "Devbox disk encryption enable or disable status. Indicates if Devbox disks encryption is enabled or not."]
1133#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1134#[serde(remote = "DevboxDisksEncryptionEnableStatus")]
1135pub enum DevboxDisksEncryptionEnableStatus {
1136 Enabled,
1137 Disabled,
1138 #[serde(skip_deserializing)]
1139 UnknownValue(String),
1140}
1141impl FromStr for DevboxDisksEncryptionEnableStatus {
1142 type Err = value::Error;
1143 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
1144 Self::deserialize(s.into_deserializer())
1145 }
1146}
1147impl<'de> Deserialize<'de> for DevboxDisksEncryptionEnableStatus {
1148 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1149 where
1150 D: Deserializer<'de>,
1151 {
1152 let s = String::deserialize(deserializer)?;
1153 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
1154 Ok(deserialized)
1155 }
1156}
1157impl Serialize for DevboxDisksEncryptionEnableStatus {
1158 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1159 where
1160 S: Serializer,
1161 {
1162 match self {
1163 Self::Enabled => serializer.serialize_unit_variant("DevboxDisksEncryptionEnableStatus", 0u32, "Enabled"),
1164 Self::Disabled => serializer.serialize_unit_variant("DevboxDisksEncryptionEnableStatus", 1u32, "Disabled"),
1165 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
1166 }
1167 }
1168}
1169#[doc = "Active Directory join type"]
1170#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1171#[serde(remote = "DomainJoinType")]
1172pub enum DomainJoinType {
1173 #[serde(rename = "HybridAzureADJoin")]
1174 HybridAzureAdJoin,
1175 #[serde(rename = "AzureADJoin")]
1176 AzureAdJoin,
1177 None,
1178 #[serde(skip_deserializing)]
1179 UnknownValue(String),
1180}
1181impl FromStr for DomainJoinType {
1182 type Err = value::Error;
1183 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
1184 Self::deserialize(s.into_deserializer())
1185 }
1186}
1187impl<'de> Deserialize<'de> for DomainJoinType {
1188 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1189 where
1190 D: Deserializer<'de>,
1191 {
1192 let s = String::deserialize(deserializer)?;
1193 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
1194 Ok(deserialized)
1195 }
1196}
1197impl Serialize for DomainJoinType {
1198 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1199 where
1200 S: Serializer,
1201 {
1202 match self {
1203 Self::HybridAzureAdJoin => serializer.serialize_unit_variant("DomainJoinType", 0u32, "HybridAzureADJoin"),
1204 Self::AzureAdJoin => serializer.serialize_unit_variant("DomainJoinType", 1u32, "AzureADJoin"),
1205 Self::None => serializer.serialize_unit_variant("DomainJoinType", 2u32, "None"),
1206 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
1207 }
1208 }
1209}
1210#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1211pub struct Encryption {
1212 #[doc = "All Customer-managed key encryption properties for the resource."]
1213 #[serde(rename = "customerManagedKeyEncryption", default, skip_serializing_if = "Option::is_none")]
1214 pub customer_managed_key_encryption: Option<CustomerManagedKeyEncryption>,
1215}
1216impl Encryption {
1217 pub fn new() -> Self {
1218 Self::default()
1219 }
1220}
1221#[doc = "Result of the list devcenter encryption set operation"]
1222#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1223pub struct EncryptionSetListResult {
1224 #[doc = "Current page of results."]
1225 #[serde(
1226 default,
1227 deserialize_with = "azure_core::util::deserialize_null_as_default",
1228 skip_serializing_if = "Vec::is_empty"
1229 )]
1230 pub value: Vec<DevCenterEncryptionSet>,
1231 #[doc = "URL to get the next set of results if there are any."]
1232 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
1233 pub next_link: Option<String>,
1234}
1235impl azure_core::Continuable for EncryptionSetListResult {
1236 type Continuation = String;
1237 fn continuation(&self) -> Option<Self::Continuation> {
1238 self.next_link.clone().filter(|value| !value.is_empty())
1239 }
1240}
1241impl EncryptionSetListResult {
1242 pub fn new() -> Self {
1243 Self::default()
1244 }
1245}
1246#[doc = "The devcenter encryption set resource for partial updates. Properties not provided in the update request will not be changed."]
1247#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1248pub struct EncryptionSetUpdate {
1249 #[serde(flatten)]
1250 pub tracked_resource_update: TrackedResourceUpdate,
1251 #[doc = "Properties of the devcenter encryption set. These properties can be updated after the resource has been created."]
1252 #[serde(default, skip_serializing_if = "Option::is_none")]
1253 pub properties: Option<DevCenterEncryptionSetUpdateProperties>,
1254 #[doc = "Managed service identity (system assigned and/or user assigned identities)"]
1255 #[serde(default, skip_serializing_if = "Option::is_none")]
1256 pub identity: Option<ManagedServiceIdentity>,
1257}
1258impl EncryptionSetUpdate {
1259 pub fn new() -> Self {
1260 Self::default()
1261 }
1262}
1263#[doc = "A domain name and connection details used to access a dependency."]
1264#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1265pub struct EndpointDependency {
1266 #[doc = "The domain name of the dependency. Domain names may be fully qualified or may contain a * wildcard."]
1267 #[serde(rename = "domainName", default, skip_serializing_if = "Option::is_none")]
1268 pub domain_name: Option<String>,
1269 #[doc = "Human-readable supplemental information about the dependency and when it is applicable."]
1270 #[serde(default, skip_serializing_if = "Option::is_none")]
1271 pub description: Option<String>,
1272 #[doc = "The list of connection details for this endpoint."]
1273 #[serde(
1274 rename = "endpointDetails",
1275 default,
1276 deserialize_with = "azure_core::util::deserialize_null_as_default",
1277 skip_serializing_if = "Vec::is_empty"
1278 )]
1279 pub endpoint_details: Vec<EndpointDetail>,
1280}
1281impl EndpointDependency {
1282 pub fn new() -> Self {
1283 Self::default()
1284 }
1285}
1286#[doc = "Details about the connection between the Batch service and the endpoint."]
1287#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1288pub struct EndpointDetail {
1289 #[doc = "The port an endpoint is connected to."]
1290 #[serde(default, skip_serializing_if = "Option::is_none")]
1291 pub port: Option<i32>,
1292}
1293impl EndpointDetail {
1294 pub fn new() -> Self {
1295 Self::default()
1296 }
1297}
1298#[doc = "Represents an environment definition catalog item."]
1299#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1300pub struct EnvironmentDefinition {
1301 #[serde(flatten)]
1302 pub proxy_resource: ProxyResource,
1303 #[doc = "Properties of an environment definition."]
1304 #[serde(default, skip_serializing_if = "Option::is_none")]
1305 pub properties: Option<EnvironmentDefinitionProperties>,
1306}
1307impl EnvironmentDefinition {
1308 pub fn new() -> Self {
1309 Self::default()
1310 }
1311}
1312#[doc = "Results of the environment definition list operation."]
1313#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1314pub struct EnvironmentDefinitionListResult {
1315 #[doc = "Current page of results."]
1316 #[serde(
1317 default,
1318 deserialize_with = "azure_core::util::deserialize_null_as_default",
1319 skip_serializing_if = "Vec::is_empty"
1320 )]
1321 pub value: Vec<EnvironmentDefinition>,
1322 #[doc = "URL to get the next set of results if there are any."]
1323 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
1324 pub next_link: Option<String>,
1325}
1326impl azure_core::Continuable for EnvironmentDefinitionListResult {
1327 type Continuation = String;
1328 fn continuation(&self) -> Option<Self::Continuation> {
1329 self.next_link.clone().filter(|value| !value.is_empty())
1330 }
1331}
1332impl EnvironmentDefinitionListResult {
1333 pub fn new() -> Self {
1334 Self::default()
1335 }
1336}
1337#[doc = "Properties of an Environment Definition parameter"]
1338#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1339pub struct EnvironmentDefinitionParameter {
1340 #[doc = "Unique ID of the parameter"]
1341 #[serde(default, skip_serializing_if = "Option::is_none")]
1342 pub id: Option<String>,
1343 #[doc = "Display name of the parameter"]
1344 #[serde(default, skip_serializing_if = "Option::is_none")]
1345 pub name: Option<String>,
1346 #[doc = "Description of the parameter"]
1347 #[serde(default, skip_serializing_if = "Option::is_none")]
1348 pub description: Option<String>,
1349 #[doc = "The type of data a parameter accepts."]
1350 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
1351 pub type_: Option<ParameterType>,
1352 #[doc = "Whether or not this parameter is read-only. If true, default should have a value."]
1353 #[serde(rename = "readOnly", default, skip_serializing_if = "Option::is_none")]
1354 pub read_only: Option<bool>,
1355 #[doc = "Whether or not this parameter is required"]
1356 #[serde(default, skip_serializing_if = "Option::is_none")]
1357 pub required: Option<bool>,
1358}
1359impl EnvironmentDefinitionParameter {
1360 pub fn new() -> Self {
1361 Self::default()
1362 }
1363}
1364#[doc = "Properties of an environment definition."]
1365#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1366pub struct EnvironmentDefinitionProperties {
1367 #[doc = "A short description of the environment definition."]
1368 #[serde(default, skip_serializing_if = "Option::is_none")]
1369 pub description: Option<String>,
1370 #[doc = "Input parameters passed to an environment."]
1371 #[serde(
1372 default,
1373 deserialize_with = "azure_core::util::deserialize_null_as_default",
1374 skip_serializing_if = "Vec::is_empty"
1375 )]
1376 pub parameters: Vec<EnvironmentDefinitionParameter>,
1377 #[doc = "Path to the Environment Definition entrypoint file."]
1378 #[serde(rename = "templatePath", default, skip_serializing_if = "Option::is_none")]
1379 pub template_path: Option<String>,
1380 #[doc = "Catalog resource validation status"]
1381 #[serde(rename = "validationStatus", default, skip_serializing_if = "Option::is_none")]
1382 pub validation_status: Option<CatalogResourceValidationStatus>,
1383}
1384impl EnvironmentDefinitionProperties {
1385 pub fn new() -> Self {
1386 Self::default()
1387 }
1388}
1389#[doc = "A role that can be assigned to a user."]
1390#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1391pub struct EnvironmentRole {
1392 #[doc = "The common name of the Role Assignment. This is a descriptive name such as 'AcrPush'."]
1393 #[serde(rename = "roleName", default, skip_serializing_if = "Option::is_none")]
1394 pub role_name: Option<String>,
1395 #[doc = "This is a description of the Role Assignment."]
1396 #[serde(default, skip_serializing_if = "Option::is_none")]
1397 pub description: Option<String>,
1398}
1399impl EnvironmentRole {
1400 pub fn new() -> Self {
1401 Self::default()
1402 }
1403}
1404#[doc = "Represents an environment type."]
1405#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1406pub struct EnvironmentType {
1407 #[serde(flatten)]
1408 pub resource: Resource,
1409 #[doc = "Properties of an environment type."]
1410 #[serde(default, skip_serializing_if = "Option::is_none")]
1411 pub properties: Option<EnvironmentTypeProperties>,
1412 #[doc = "Resource tags."]
1413 #[serde(default, skip_serializing_if = "Option::is_none")]
1414 pub tags: Option<Tags>,
1415}
1416impl EnvironmentType {
1417 pub fn new() -> Self {
1418 Self::default()
1419 }
1420}
1421#[doc = "Indicates whether the environment type is either enabled or disabled."]
1422#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1423#[serde(remote = "EnvironmentTypeEnableStatus")]
1424pub enum EnvironmentTypeEnableStatus {
1425 Enabled,
1426 Disabled,
1427 #[serde(skip_deserializing)]
1428 UnknownValue(String),
1429}
1430impl FromStr for EnvironmentTypeEnableStatus {
1431 type Err = value::Error;
1432 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
1433 Self::deserialize(s.into_deserializer())
1434 }
1435}
1436impl<'de> Deserialize<'de> for EnvironmentTypeEnableStatus {
1437 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1438 where
1439 D: Deserializer<'de>,
1440 {
1441 let s = String::deserialize(deserializer)?;
1442 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
1443 Ok(deserialized)
1444 }
1445}
1446impl Serialize for EnvironmentTypeEnableStatus {
1447 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1448 where
1449 S: Serializer,
1450 {
1451 match self {
1452 Self::Enabled => serializer.serialize_unit_variant("EnvironmentTypeEnableStatus", 0u32, "Enabled"),
1453 Self::Disabled => serializer.serialize_unit_variant("EnvironmentTypeEnableStatus", 1u32, "Disabled"),
1454 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
1455 }
1456 }
1457}
1458#[doc = "Result of the environment type list operation."]
1459#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1460pub struct EnvironmentTypeListResult {
1461 #[doc = "Current page of results."]
1462 #[serde(
1463 default,
1464 deserialize_with = "azure_core::util::deserialize_null_as_default",
1465 skip_serializing_if = "Vec::is_empty"
1466 )]
1467 pub value: Vec<EnvironmentType>,
1468 #[doc = "URL to get the next set of results if there are any."]
1469 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
1470 pub next_link: Option<String>,
1471}
1472impl azure_core::Continuable for EnvironmentTypeListResult {
1473 type Continuation = String;
1474 fn continuation(&self) -> Option<Self::Continuation> {
1475 self.next_link.clone().filter(|value| !value.is_empty())
1476 }
1477}
1478impl EnvironmentTypeListResult {
1479 pub fn new() -> Self {
1480 Self::default()
1481 }
1482}
1483#[doc = "Properties of an environment type."]
1484#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1485pub struct EnvironmentTypeProperties {
1486 #[serde(flatten)]
1487 pub environment_type_update_properties: EnvironmentTypeUpdateProperties,
1488 #[doc = "Provisioning state of the resource."]
1489 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
1490 pub provisioning_state: Option<ProvisioningState>,
1491}
1492impl EnvironmentTypeProperties {
1493 pub fn new() -> Self {
1494 Self::default()
1495 }
1496}
1497#[doc = "The environment type for partial update. Properties not provided in the update request will not be changed."]
1498#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1499pub struct EnvironmentTypeUpdate {
1500 #[doc = "Properties of an environment type. These properties can be updated after the resource has been created."]
1501 #[serde(default, skip_serializing_if = "Option::is_none")]
1502 pub properties: Option<EnvironmentTypeUpdateProperties>,
1503 #[doc = "Resource tags."]
1504 #[serde(default, skip_serializing_if = "Option::is_none")]
1505 pub tags: Option<Tags>,
1506}
1507impl EnvironmentTypeUpdate {
1508 pub fn new() -> Self {
1509 Self::default()
1510 }
1511}
1512#[doc = "Properties of an environment type. These properties can be updated after the resource has been created."]
1513#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1514pub struct EnvironmentTypeUpdateProperties {
1515 #[doc = "The display name of the environment type."]
1516 #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
1517 pub display_name: Option<String>,
1518}
1519impl EnvironmentTypeUpdateProperties {
1520 pub fn new() -> Self {
1521 Self::default()
1522 }
1523}
1524#[doc = "The resource management error additional info."]
1525#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1526pub struct ErrorAdditionalInfo {
1527 #[doc = "The additional info type."]
1528 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
1529 pub type_: Option<String>,
1530 #[doc = "The additional info."]
1531 #[serde(default, skip_serializing_if = "Option::is_none")]
1532 pub info: Option<serde_json::Value>,
1533}
1534impl ErrorAdditionalInfo {
1535 pub fn new() -> Self {
1536 Self::default()
1537 }
1538}
1539#[doc = "The error detail."]
1540#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1541pub struct ErrorDetail {
1542 #[doc = "The error code."]
1543 #[serde(default, skip_serializing_if = "Option::is_none")]
1544 pub code: Option<String>,
1545 #[doc = "The error message."]
1546 #[serde(default, skip_serializing_if = "Option::is_none")]
1547 pub message: Option<String>,
1548 #[doc = "The error target."]
1549 #[serde(default, skip_serializing_if = "Option::is_none")]
1550 pub target: Option<String>,
1551 #[doc = "The error details."]
1552 #[serde(
1553 default,
1554 deserialize_with = "azure_core::util::deserialize_null_as_default",
1555 skip_serializing_if = "Vec::is_empty"
1556 )]
1557 pub details: Vec<ErrorDetail>,
1558 #[doc = "The error additional info."]
1559 #[serde(
1560 rename = "additionalInfo",
1561 default,
1562 deserialize_with = "azure_core::util::deserialize_null_as_default",
1563 skip_serializing_if = "Vec::is_empty"
1564 )]
1565 pub additional_info: Vec<ErrorAdditionalInfo>,
1566}
1567impl ErrorDetail {
1568 pub fn new() -> Self {
1569 Self::default()
1570 }
1571}
1572#[doc = "Common error response for all Azure Resource Manager APIs to return error details for failed operations. (This also follows the OData error response format.)."]
1573#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1574pub struct ErrorResponse {
1575 #[doc = "The error detail."]
1576 #[serde(default, skip_serializing_if = "Option::is_none")]
1577 pub error: Option<ErrorDetail>,
1578}
1579impl azure_core::Continuable for ErrorResponse {
1580 type Continuation = String;
1581 fn continuation(&self) -> Option<Self::Continuation> {
1582 None
1583 }
1584}
1585impl ErrorResponse {
1586 pub fn new() -> Self {
1587 Self::default()
1588 }
1589}
1590#[doc = "Represents a gallery."]
1591#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1592pub struct Gallery {
1593 #[serde(flatten)]
1594 pub resource: Resource,
1595 #[doc = "Properties of a gallery."]
1596 #[serde(default, skip_serializing_if = "Option::is_none")]
1597 pub properties: Option<GalleryProperties>,
1598}
1599impl Gallery {
1600 pub fn new() -> Self {
1601 Self::default()
1602 }
1603}
1604#[doc = "Results of the gallery list operation."]
1605#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1606pub struct GalleryListResult {
1607 #[doc = "Current page of results."]
1608 #[serde(
1609 default,
1610 deserialize_with = "azure_core::util::deserialize_null_as_default",
1611 skip_serializing_if = "Vec::is_empty"
1612 )]
1613 pub value: Vec<Gallery>,
1614 #[doc = "URL to get the next set of results if there are any."]
1615 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
1616 pub next_link: Option<String>,
1617}
1618impl azure_core::Continuable for GalleryListResult {
1619 type Continuation = String;
1620 fn continuation(&self) -> Option<Self::Continuation> {
1621 self.next_link.clone().filter(|value| !value.is_empty())
1622 }
1623}
1624impl GalleryListResult {
1625 pub fn new() -> Self {
1626 Self::default()
1627 }
1628}
1629#[doc = "Properties of a gallery."]
1630#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1631pub struct GalleryProperties {
1632 #[doc = "Provisioning state of the resource."]
1633 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
1634 pub provisioning_state: Option<ProvisioningState>,
1635 #[doc = "The resource ID of the backing Azure Compute Gallery."]
1636 #[serde(rename = "galleryResourceId")]
1637 pub gallery_resource_id: String,
1638}
1639impl GalleryProperties {
1640 pub fn new(gallery_resource_id: String) -> Self {
1641 Self {
1642 provisioning_state: None,
1643 gallery_resource_id,
1644 }
1645 }
1646}
1647#[doc = "Properties for a Git repository catalog."]
1648#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1649pub struct GitCatalog {
1650 #[doc = "Git URI."]
1651 #[serde(default, skip_serializing_if = "Option::is_none")]
1652 pub uri: Option<String>,
1653 #[doc = "Git branch."]
1654 #[serde(default, skip_serializing_if = "Option::is_none")]
1655 pub branch: Option<String>,
1656 #[doc = "A reference to the Key Vault secret containing a security token to authenticate to a Git repository."]
1657 #[serde(rename = "secretIdentifier", default, skip_serializing_if = "Option::is_none")]
1658 pub secret_identifier: Option<String>,
1659 #[doc = "The folder where the catalog items can be found inside the repository."]
1660 #[serde(default, skip_serializing_if = "Option::is_none")]
1661 pub path: Option<String>,
1662}
1663impl GitCatalog {
1664 pub fn new() -> Self {
1665 Self::default()
1666 }
1667}
1668#[doc = "An individual health check item"]
1669#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1670pub struct HealthCheck {
1671 #[doc = "Health check status values"]
1672 #[serde(default, skip_serializing_if = "Option::is_none")]
1673 pub status: Option<HealthCheckStatus>,
1674 #[doc = "The display name of this health check item."]
1675 #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
1676 pub display_name: Option<String>,
1677 #[doc = "Start time of health check item."]
1678 #[serde(rename = "startDateTime", default, with = "azure_core::date::rfc3339::option")]
1679 pub start_date_time: Option<::time::OffsetDateTime>,
1680 #[doc = "End time of the health check item."]
1681 #[serde(rename = "endDateTime", default, with = "azure_core::date::rfc3339::option")]
1682 pub end_date_time: Option<::time::OffsetDateTime>,
1683 #[doc = "The type of error that occurred during this health check."]
1684 #[serde(rename = "errorType", default, skip_serializing_if = "Option::is_none")]
1685 pub error_type: Option<String>,
1686 #[doc = "The recommended action to fix the corresponding error."]
1687 #[serde(rename = "recommendedAction", default, skip_serializing_if = "Option::is_none")]
1688 pub recommended_action: Option<String>,
1689 #[doc = "Additional details about the health check or the recommended action."]
1690 #[serde(rename = "additionalDetails", default, skip_serializing_if = "Option::is_none")]
1691 pub additional_details: Option<String>,
1692}
1693impl HealthCheck {
1694 pub fn new() -> Self {
1695 Self::default()
1696 }
1697}
1698#[doc = "Health check status values"]
1699#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1700#[serde(remote = "HealthCheckStatus")]
1701pub enum HealthCheckStatus {
1702 Unknown,
1703 Pending,
1704 Running,
1705 Passed,
1706 Warning,
1707 Failed,
1708 #[serde(skip_deserializing)]
1709 UnknownValue(String),
1710}
1711impl FromStr for HealthCheckStatus {
1712 type Err = value::Error;
1713 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
1714 Self::deserialize(s.into_deserializer())
1715 }
1716}
1717impl<'de> Deserialize<'de> for HealthCheckStatus {
1718 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1719 where
1720 D: Deserializer<'de>,
1721 {
1722 let s = String::deserialize(deserializer)?;
1723 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
1724 Ok(deserialized)
1725 }
1726}
1727impl Serialize for HealthCheckStatus {
1728 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1729 where
1730 S: Serializer,
1731 {
1732 match self {
1733 Self::Unknown => serializer.serialize_unit_variant("HealthCheckStatus", 0u32, "Unknown"),
1734 Self::Pending => serializer.serialize_unit_variant("HealthCheckStatus", 1u32, "Pending"),
1735 Self::Running => serializer.serialize_unit_variant("HealthCheckStatus", 2u32, "Running"),
1736 Self::Passed => serializer.serialize_unit_variant("HealthCheckStatus", 3u32, "Passed"),
1737 Self::Warning => serializer.serialize_unit_variant("HealthCheckStatus", 4u32, "Warning"),
1738 Self::Failed => serializer.serialize_unit_variant("HealthCheckStatus", 5u32, "Failed"),
1739 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
1740 }
1741 }
1742}
1743#[doc = "Health Check details."]
1744#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1745pub struct HealthCheckStatusDetails {
1746 #[serde(flatten)]
1747 pub resource: Resource,
1748 #[doc = "Health Check properties."]
1749 #[serde(default, skip_serializing_if = "Option::is_none")]
1750 pub properties: Option<HealthCheckStatusDetailsProperties>,
1751}
1752impl HealthCheckStatusDetails {
1753 pub fn new() -> Self {
1754 Self::default()
1755 }
1756}
1757#[doc = "Result of the network health check list operation."]
1758#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1759pub struct HealthCheckStatusDetailsListResult {
1760 #[doc = "Current page of results."]
1761 #[serde(
1762 default,
1763 deserialize_with = "azure_core::util::deserialize_null_as_default",
1764 skip_serializing_if = "Vec::is_empty"
1765 )]
1766 pub value: Vec<HealthCheckStatusDetails>,
1767 #[doc = "URL to get the next set of results if there are any."]
1768 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
1769 pub next_link: Option<String>,
1770}
1771impl azure_core::Continuable for HealthCheckStatusDetailsListResult {
1772 type Continuation = String;
1773 fn continuation(&self) -> Option<Self::Continuation> {
1774 None
1775 }
1776}
1777impl HealthCheckStatusDetailsListResult {
1778 pub fn new() -> Self {
1779 Self::default()
1780 }
1781}
1782#[doc = "Health Check properties."]
1783#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1784pub struct HealthCheckStatusDetailsProperties {
1785 #[doc = "Start time of last execution of the health checks."]
1786 #[serde(rename = "startDateTime", default, with = "azure_core::date::rfc3339::option")]
1787 pub start_date_time: Option<::time::OffsetDateTime>,
1788 #[doc = "End time of last execution of the health checks."]
1789 #[serde(rename = "endDateTime", default, with = "azure_core::date::rfc3339::option")]
1790 pub end_date_time: Option<::time::OffsetDateTime>,
1791 #[doc = "Details for each health check item."]
1792 #[serde(
1793 rename = "healthChecks",
1794 default,
1795 deserialize_with = "azure_core::util::deserialize_null_as_default",
1796 skip_serializing_if = "Vec::is_empty"
1797 )]
1798 pub health_checks: Vec<HealthCheck>,
1799}
1800impl HealthCheckStatusDetailsProperties {
1801 pub fn new() -> Self {
1802 Self::default()
1803 }
1804}
1805#[doc = "Health status indicating whether a pool is available to create Dev Boxes."]
1806#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1807#[serde(remote = "HealthStatus")]
1808pub enum HealthStatus {
1809 Unknown,
1810 Pending,
1811 Healthy,
1812 Warning,
1813 Unhealthy,
1814 #[serde(skip_deserializing)]
1815 UnknownValue(String),
1816}
1817impl FromStr for HealthStatus {
1818 type Err = value::Error;
1819 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
1820 Self::deserialize(s.into_deserializer())
1821 }
1822}
1823impl<'de> Deserialize<'de> for HealthStatus {
1824 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1825 where
1826 D: Deserializer<'de>,
1827 {
1828 let s = String::deserialize(deserializer)?;
1829 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
1830 Ok(deserialized)
1831 }
1832}
1833impl Serialize for HealthStatus {
1834 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1835 where
1836 S: Serializer,
1837 {
1838 match self {
1839 Self::Unknown => serializer.serialize_unit_variant("HealthStatus", 0u32, "Unknown"),
1840 Self::Pending => serializer.serialize_unit_variant("HealthStatus", 1u32, "Pending"),
1841 Self::Healthy => serializer.serialize_unit_variant("HealthStatus", 2u32, "Healthy"),
1842 Self::Warning => serializer.serialize_unit_variant("HealthStatus", 3u32, "Warning"),
1843 Self::Unhealthy => serializer.serialize_unit_variant("HealthStatus", 4u32, "Unhealthy"),
1844 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
1845 }
1846 }
1847}
1848#[doc = "Pool health status detail."]
1849#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1850pub struct HealthStatusDetail {
1851 #[doc = "An identifier for the issue."]
1852 #[serde(default, skip_serializing_if = "Option::is_none")]
1853 pub code: Option<String>,
1854 #[doc = "A message describing the issue, intended to be suitable for display in a user interface"]
1855 #[serde(default, skip_serializing_if = "Option::is_none")]
1856 pub message: Option<String>,
1857}
1858impl HealthStatusDetail {
1859 pub fn new() -> Self {
1860 Self::default()
1861 }
1862}
1863#[doc = "Indicates whether hibernate is enabled/disabled."]
1864#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1865#[serde(remote = "HibernateSupport")]
1866pub enum HibernateSupport {
1867 Disabled,
1868 Enabled,
1869 #[serde(skip_deserializing)]
1870 UnknownValue(String),
1871}
1872impl FromStr for HibernateSupport {
1873 type Err = value::Error;
1874 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
1875 Self::deserialize(s.into_deserializer())
1876 }
1877}
1878impl<'de> Deserialize<'de> for HibernateSupport {
1879 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1880 where
1881 D: Deserializer<'de>,
1882 {
1883 let s = String::deserialize(deserializer)?;
1884 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
1885 Ok(deserialized)
1886 }
1887}
1888impl Serialize for HibernateSupport {
1889 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1890 where
1891 S: Serializer,
1892 {
1893 match self {
1894 Self::Disabled => serializer.serialize_unit_variant("HibernateSupport", 0u32, "Disabled"),
1895 Self::Enabled => serializer.serialize_unit_variant("HibernateSupport", 1u32, "Enabled"),
1896 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
1897 }
1898 }
1899}
1900#[doc = "Represents an image."]
1901#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1902pub struct Image {
1903 #[serde(flatten)]
1904 pub proxy_resource: ProxyResource,
1905 #[doc = "Properties of an image."]
1906 #[serde(default, skip_serializing_if = "Option::is_none")]
1907 pub properties: Option<ImageProperties>,
1908}
1909impl Image {
1910 pub fn new() -> Self {
1911 Self::default()
1912 }
1913}
1914#[doc = "Represents a definition for an Image."]
1915#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1916pub struct ImageDefinition {
1917 #[serde(flatten)]
1918 pub proxy_resource: ProxyResource,
1919 #[doc = "Properties of an Image Definition."]
1920 #[serde(default, skip_serializing_if = "Option::is_none")]
1921 pub properties: Option<ImageDefinitionProperties>,
1922}
1923impl ImageDefinition {
1924 pub fn new() -> Self {
1925 Self::default()
1926 }
1927}
1928#[doc = "Results of the Image Definition list operation."]
1929#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1930pub struct ImageDefinitionListResult {
1931 #[doc = "Current page of results."]
1932 #[serde(
1933 default,
1934 deserialize_with = "azure_core::util::deserialize_null_as_default",
1935 skip_serializing_if = "Vec::is_empty"
1936 )]
1937 pub value: Vec<ImageDefinition>,
1938 #[doc = "URL to get the next set of results if there are any."]
1939 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
1940 pub next_link: Option<String>,
1941}
1942impl azure_core::Continuable for ImageDefinitionListResult {
1943 type Continuation = String;
1944 fn continuation(&self) -> Option<Self::Continuation> {
1945 self.next_link.clone().filter(|value| !value.is_empty())
1946 }
1947}
1948impl ImageDefinitionListResult {
1949 pub fn new() -> Self {
1950 Self::default()
1951 }
1952}
1953#[doc = "Properties of an Image Definition."]
1954#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1955pub struct ImageDefinitionProperties {
1956 #[doc = "Image reference information"]
1957 #[serde(rename = "imageReference")]
1958 pub image_reference: ImageReference,
1959}
1960impl ImageDefinitionProperties {
1961 pub fn new(image_reference: ImageReference) -> Self {
1962 Self { image_reference }
1963 }
1964}
1965#[doc = "Results of the image list operation."]
1966#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1967pub struct ImageListResult {
1968 #[doc = "Current page of results."]
1969 #[serde(
1970 default,
1971 deserialize_with = "azure_core::util::deserialize_null_as_default",
1972 skip_serializing_if = "Vec::is_empty"
1973 )]
1974 pub value: Vec<Image>,
1975 #[doc = "URL to get the next set of results if there are any."]
1976 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
1977 pub next_link: Option<String>,
1978}
1979impl azure_core::Continuable for ImageListResult {
1980 type Continuation = String;
1981 fn continuation(&self) -> Option<Self::Continuation> {
1982 self.next_link.clone().filter(|value| !value.is_empty())
1983 }
1984}
1985impl ImageListResult {
1986 pub fn new() -> Self {
1987 Self::default()
1988 }
1989}
1990#[doc = "Properties of an image."]
1991#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1992pub struct ImageProperties {
1993 #[doc = "The description of the image."]
1994 #[serde(default, skip_serializing_if = "Option::is_none")]
1995 pub description: Option<String>,
1996 #[doc = "The publisher of the image."]
1997 #[serde(default, skip_serializing_if = "Option::is_none")]
1998 pub publisher: Option<String>,
1999 #[doc = "The name of the image offer."]
2000 #[serde(default, skip_serializing_if = "Option::is_none")]
2001 pub offer: Option<String>,
2002 #[doc = "The SKU name for the image."]
2003 #[serde(default, skip_serializing_if = "Option::is_none")]
2004 pub sku: Option<String>,
2005 #[doc = "Properties for a recommended machine configuration."]
2006 #[serde(rename = "recommendedMachineConfiguration", default, skip_serializing_if = "Option::is_none")]
2007 pub recommended_machine_configuration: Option<RecommendedMachineConfiguration>,
2008 #[doc = "Provisioning state of the resource."]
2009 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
2010 pub provisioning_state: Option<ProvisioningState>,
2011 #[doc = "Indicates whether hibernate is enabled/disabled."]
2012 #[serde(rename = "hibernateSupport", default, skip_serializing_if = "Option::is_none")]
2013 pub hibernate_support: Option<HibernateSupport>,
2014}
2015impl ImageProperties {
2016 pub fn new() -> Self {
2017 Self::default()
2018 }
2019}
2020#[doc = "Image reference information"]
2021#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2022pub struct ImageReference {
2023 #[doc = "Image ID, or Image version ID. When Image ID is provided, its latest version will be used."]
2024 #[serde(default, skip_serializing_if = "Option::is_none")]
2025 pub id: Option<String>,
2026 #[doc = "The actual version of the image after use. When id references a gallery image latest version, this will indicate the actual version in use."]
2027 #[serde(rename = "exactVersion", default, skip_serializing_if = "Option::is_none")]
2028 pub exact_version: Option<String>,
2029}
2030impl ImageReference {
2031 pub fn new() -> Self {
2032 Self::default()
2033 }
2034}
2035#[doc = "Image validation error details"]
2036#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2037pub struct ImageValidationErrorDetails {
2038 #[doc = "An identifier for the error."]
2039 #[serde(default, skip_serializing_if = "Option::is_none")]
2040 pub code: Option<String>,
2041 #[doc = "A message describing the error."]
2042 #[serde(default, skip_serializing_if = "Option::is_none")]
2043 pub message: Option<String>,
2044}
2045impl ImageValidationErrorDetails {
2046 pub fn new() -> Self {
2047 Self::default()
2048 }
2049}
2050#[doc = "Image validation status"]
2051#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2052#[serde(remote = "ImageValidationStatus")]
2053pub enum ImageValidationStatus {
2054 Unknown,
2055 Pending,
2056 Succeeded,
2057 Failed,
2058 TimedOut,
2059 #[serde(skip_deserializing)]
2060 UnknownValue(String),
2061}
2062impl FromStr for ImageValidationStatus {
2063 type Err = value::Error;
2064 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
2065 Self::deserialize(s.into_deserializer())
2066 }
2067}
2068impl<'de> Deserialize<'de> for ImageValidationStatus {
2069 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2070 where
2071 D: Deserializer<'de>,
2072 {
2073 let s = String::deserialize(deserializer)?;
2074 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
2075 Ok(deserialized)
2076 }
2077}
2078impl Serialize for ImageValidationStatus {
2079 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2080 where
2081 S: Serializer,
2082 {
2083 match self {
2084 Self::Unknown => serializer.serialize_unit_variant("ImageValidationStatus", 0u32, "Unknown"),
2085 Self::Pending => serializer.serialize_unit_variant("ImageValidationStatus", 1u32, "Pending"),
2086 Self::Succeeded => serializer.serialize_unit_variant("ImageValidationStatus", 2u32, "Succeeded"),
2087 Self::Failed => serializer.serialize_unit_variant("ImageValidationStatus", 3u32, "Failed"),
2088 Self::TimedOut => serializer.serialize_unit_variant("ImageValidationStatus", 4u32, "TimedOut"),
2089 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
2090 }
2091 }
2092}
2093#[doc = "Represents an image version."]
2094#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2095pub struct ImageVersion {
2096 #[serde(flatten)]
2097 pub proxy_resource: ProxyResource,
2098 #[doc = "Properties of an image version."]
2099 #[serde(default, skip_serializing_if = "Option::is_none")]
2100 pub properties: Option<ImageVersionProperties>,
2101}
2102impl ImageVersion {
2103 pub fn new() -> Self {
2104 Self::default()
2105 }
2106}
2107#[doc = "Results of the image version list operation."]
2108#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2109pub struct ImageVersionListResult {
2110 #[doc = "Current page of results."]
2111 #[serde(
2112 default,
2113 deserialize_with = "azure_core::util::deserialize_null_as_default",
2114 skip_serializing_if = "Vec::is_empty"
2115 )]
2116 pub value: Vec<ImageVersion>,
2117 #[doc = "URL to get the next set of results if there are any."]
2118 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
2119 pub next_link: Option<String>,
2120}
2121impl azure_core::Continuable for ImageVersionListResult {
2122 type Continuation = String;
2123 fn continuation(&self) -> Option<Self::Continuation> {
2124 self.next_link.clone().filter(|value| !value.is_empty())
2125 }
2126}
2127impl ImageVersionListResult {
2128 pub fn new() -> Self {
2129 Self::default()
2130 }
2131}
2132#[doc = "Properties of an image version."]
2133#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2134pub struct ImageVersionProperties {
2135 #[doc = "The semantic version string."]
2136 #[serde(default, skip_serializing_if = "Option::is_none")]
2137 pub name: Option<String>,
2138 #[doc = "The datetime that the backing image version was published."]
2139 #[serde(rename = "publishedDate", default, with = "azure_core::date::rfc3339::option")]
2140 pub published_date: Option<::time::OffsetDateTime>,
2141 #[doc = "If the version should be excluded from being treated as the latest version."]
2142 #[serde(rename = "excludeFromLatest", default, skip_serializing_if = "Option::is_none")]
2143 pub exclude_from_latest: Option<bool>,
2144 #[doc = "The size of the OS disk image, in GB."]
2145 #[serde(rename = "osDiskImageSizeInGb", default, skip_serializing_if = "Option::is_none")]
2146 pub os_disk_image_size_in_gb: Option<i32>,
2147 #[doc = "Provisioning state of the resource."]
2148 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
2149 pub provisioning_state: Option<ProvisioningState>,
2150}
2151impl ImageVersionProperties {
2152 pub fn new() -> Self {
2153 Self::default()
2154 }
2155}
2156#[doc = "Applicable inherited settings for a project."]
2157#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2158pub struct InheritedSettingsForProject {
2159 #[doc = "Project catalog settings for project catalogs under a project associated to this dev center."]
2160 #[serde(rename = "projectCatalogSettings", default, skip_serializing_if = "Option::is_none")]
2161 pub project_catalog_settings: Option<DevCenterProjectCatalogSettings>,
2162 #[doc = "Network settings for the project."]
2163 #[serde(rename = "networkSettings", default, skip_serializing_if = "Option::is_none")]
2164 pub network_settings: Option<ProjectNetworkSettings>,
2165}
2166impl InheritedSettingsForProject {
2167 pub fn new() -> Self {
2168 Self::default()
2169 }
2170}
2171#[doc = "Setting to be used when determining whether to install the Azure Monitor Agent service on Dev Boxes that belong to this dev center."]
2172#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2173#[serde(remote = "InstallAzureMonitorAgentEnableStatus")]
2174pub enum InstallAzureMonitorAgentEnableStatus {
2175 Enabled,
2176 Disabled,
2177 #[serde(skip_deserializing)]
2178 UnknownValue(String),
2179}
2180impl FromStr for InstallAzureMonitorAgentEnableStatus {
2181 type Err = value::Error;
2182 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
2183 Self::deserialize(s.into_deserializer())
2184 }
2185}
2186impl<'de> Deserialize<'de> for InstallAzureMonitorAgentEnableStatus {
2187 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2188 where
2189 D: Deserializer<'de>,
2190 {
2191 let s = String::deserialize(deserializer)?;
2192 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
2193 Ok(deserialized)
2194 }
2195}
2196impl Serialize for InstallAzureMonitorAgentEnableStatus {
2197 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2198 where
2199 S: Serializer,
2200 {
2201 match self {
2202 Self::Enabled => serializer.serialize_unit_variant("InstallAzureMonitorAgentEnableStatus", 0u32, "Enabled"),
2203 Self::Disabled => serializer.serialize_unit_variant("InstallAzureMonitorAgentEnableStatus", 1u32, "Disabled"),
2204 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
2205 }
2206 }
2207}
2208#[doc = "License Types"]
2209#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2210#[serde(remote = "LicenseType")]
2211pub enum LicenseType {
2212 #[serde(rename = "Windows_Client")]
2213 WindowsClient,
2214 #[serde(skip_deserializing)]
2215 UnknownValue(String),
2216}
2217impl FromStr for LicenseType {
2218 type Err = value::Error;
2219 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
2220 Self::deserialize(s.into_deserializer())
2221 }
2222}
2223impl<'de> Deserialize<'de> for LicenseType {
2224 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2225 where
2226 D: Deserializer<'de>,
2227 {
2228 let s = String::deserialize(deserializer)?;
2229 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
2230 Ok(deserialized)
2231 }
2232}
2233impl Serialize for LicenseType {
2234 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2235 where
2236 S: Serializer,
2237 {
2238 match self {
2239 Self::WindowsClient => serializer.serialize_unit_variant("LicenseType", 0u32, "Windows_Client"),
2240 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
2241 }
2242 }
2243}
2244#[doc = "List of Core Usages."]
2245#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2246pub struct ListUsagesResult {
2247 #[doc = "The array page of Usages."]
2248 #[serde(
2249 default,
2250 deserialize_with = "azure_core::util::deserialize_null_as_default",
2251 skip_serializing_if = "Vec::is_empty"
2252 )]
2253 pub value: Vec<Usage>,
2254 #[doc = "The link to get the next page of Usage result."]
2255 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
2256 pub next_link: Option<String>,
2257}
2258impl azure_core::Continuable for ListUsagesResult {
2259 type Continuation = String;
2260 fn continuation(&self) -> Option<Self::Continuation> {
2261 self.next_link.clone().filter(|value| !value.is_empty())
2262 }
2263}
2264impl ListUsagesResult {
2265 pub fn new() -> Self {
2266 Self::default()
2267 }
2268}
2269#[doc = "Local Administrator enable or disable status. Indicates whether owners of Dev Boxes are added as local administrators on the Dev Box."]
2270#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2271#[serde(remote = "LocalAdminStatus")]
2272pub enum LocalAdminStatus {
2273 Disabled,
2274 Enabled,
2275 #[serde(skip_deserializing)]
2276 UnknownValue(String),
2277}
2278impl FromStr for LocalAdminStatus {
2279 type Err = value::Error;
2280 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
2281 Self::deserialize(s.into_deserializer())
2282 }
2283}
2284impl<'de> Deserialize<'de> for LocalAdminStatus {
2285 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2286 where
2287 D: Deserializer<'de>,
2288 {
2289 let s = String::deserialize(deserializer)?;
2290 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
2291 Ok(deserialized)
2292 }
2293}
2294impl Serialize for LocalAdminStatus {
2295 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2296 where
2297 S: Serializer,
2298 {
2299 match self {
2300 Self::Disabled => serializer.serialize_unit_variant("LocalAdminStatus", 0u32, "Disabled"),
2301 Self::Enabled => serializer.serialize_unit_variant("LocalAdminStatus", 1u32, "Enabled"),
2302 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
2303 }
2304 }
2305}
2306#[doc = "Managed service identity (system assigned and/or user assigned identities)"]
2307#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2308pub struct ManagedServiceIdentity {
2309 #[doc = "The service principal ID of the system assigned identity. This property will only be provided for a system assigned identity."]
2310 #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
2311 pub principal_id: Option<String>,
2312 #[doc = "The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity."]
2313 #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
2314 pub tenant_id: Option<String>,
2315 #[doc = "Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed)."]
2316 #[serde(rename = "type")]
2317 pub type_: ManagedServiceIdentityType,
2318 #[doc = "The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests."]
2319 #[serde(rename = "userAssignedIdentities", default, skip_serializing_if = "Option::is_none")]
2320 pub user_assigned_identities: Option<UserAssignedIdentities>,
2321}
2322impl ManagedServiceIdentity {
2323 pub fn new(type_: ManagedServiceIdentityType) -> Self {
2324 Self {
2325 principal_id: None,
2326 tenant_id: None,
2327 type_,
2328 user_assigned_identities: None,
2329 }
2330 }
2331}
2332#[doc = "Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed)."]
2333#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2334#[serde(remote = "ManagedServiceIdentityType")]
2335pub enum ManagedServiceIdentityType {
2336 None,
2337 SystemAssigned,
2338 UserAssigned,
2339 #[serde(rename = "SystemAssigned, UserAssigned")]
2340 SystemAssignedUserAssigned,
2341 #[serde(skip_deserializing)]
2342 UnknownValue(String),
2343}
2344impl FromStr for ManagedServiceIdentityType {
2345 type Err = value::Error;
2346 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
2347 Self::deserialize(s.into_deserializer())
2348 }
2349}
2350impl<'de> Deserialize<'de> for ManagedServiceIdentityType {
2351 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2352 where
2353 D: Deserializer<'de>,
2354 {
2355 let s = String::deserialize(deserializer)?;
2356 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
2357 Ok(deserialized)
2358 }
2359}
2360impl Serialize for ManagedServiceIdentityType {
2361 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2362 where
2363 S: Serializer,
2364 {
2365 match self {
2366 Self::None => serializer.serialize_unit_variant("ManagedServiceIdentityType", 0u32, "None"),
2367 Self::SystemAssigned => serializer.serialize_unit_variant("ManagedServiceIdentityType", 1u32, "SystemAssigned"),
2368 Self::UserAssigned => serializer.serialize_unit_variant("ManagedServiceIdentityType", 2u32, "UserAssigned"),
2369 Self::SystemAssignedUserAssigned => {
2370 serializer.serialize_unit_variant("ManagedServiceIdentityType", 3u32, "SystemAssigned, UserAssigned")
2371 }
2372 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
2373 }
2374 }
2375}
2376#[doc = "Indicates whether pools in this Dev Center can use Microsoft Hosted Networks. Defaults to Enabled if not set."]
2377#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2378#[serde(remote = "MicrosoftHostedNetworkEnableStatus")]
2379pub enum MicrosoftHostedNetworkEnableStatus {
2380 Enabled,
2381 Disabled,
2382 #[serde(skip_deserializing)]
2383 UnknownValue(String),
2384}
2385impl FromStr for MicrosoftHostedNetworkEnableStatus {
2386 type Err = value::Error;
2387 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
2388 Self::deserialize(s.into_deserializer())
2389 }
2390}
2391impl<'de> Deserialize<'de> for MicrosoftHostedNetworkEnableStatus {
2392 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2393 where
2394 D: Deserializer<'de>,
2395 {
2396 let s = String::deserialize(deserializer)?;
2397 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
2398 Ok(deserialized)
2399 }
2400}
2401impl Serialize for MicrosoftHostedNetworkEnableStatus {
2402 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2403 where
2404 S: Serializer,
2405 {
2406 match self {
2407 Self::Enabled => serializer.serialize_unit_variant("MicrosoftHostedNetworkEnableStatus", 0u32, "Enabled"),
2408 Self::Disabled => serializer.serialize_unit_variant("MicrosoftHostedNetworkEnableStatus", 1u32, "Disabled"),
2409 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
2410 }
2411 }
2412}
2413#[doc = "Network related settings"]
2414#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2415pub struct NetworkConnection {
2416 #[serde(flatten)]
2417 pub tracked_resource: TrackedResource,
2418 #[doc = "Network properties"]
2419 #[serde(default, skip_serializing_if = "Option::is_none")]
2420 pub properties: Option<NetworkProperties>,
2421}
2422impl NetworkConnection {
2423 pub fn new(tracked_resource: TrackedResource) -> Self {
2424 Self {
2425 tracked_resource,
2426 properties: None,
2427 }
2428 }
2429}
2430#[doc = "Result of the network connection list operation."]
2431#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2432pub struct NetworkConnectionListResult {
2433 #[doc = "Current page of results."]
2434 #[serde(
2435 default,
2436 deserialize_with = "azure_core::util::deserialize_null_as_default",
2437 skip_serializing_if = "Vec::is_empty"
2438 )]
2439 pub value: Vec<NetworkConnection>,
2440 #[doc = "URL to get the next set of results if there are any."]
2441 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
2442 pub next_link: Option<String>,
2443}
2444impl azure_core::Continuable for NetworkConnectionListResult {
2445 type Continuation = String;
2446 fn continuation(&self) -> Option<Self::Continuation> {
2447 self.next_link.clone().filter(|value| !value.is_empty())
2448 }
2449}
2450impl NetworkConnectionListResult {
2451 pub fn new() -> Self {
2452 Self::default()
2453 }
2454}
2455#[doc = "The network connection properties for partial update. Properties not provided in the update request will not be changed."]
2456#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2457pub struct NetworkConnectionUpdate {
2458 #[serde(flatten)]
2459 pub tracked_resource_update: TrackedResourceUpdate,
2460 #[doc = "Properties of network connection. These properties can be updated after the resource has been created."]
2461 #[serde(default, skip_serializing_if = "Option::is_none")]
2462 pub properties: Option<NetworkConnectionUpdateProperties>,
2463}
2464impl NetworkConnectionUpdate {
2465 pub fn new() -> Self {
2466 Self::default()
2467 }
2468}
2469#[doc = "Properties of network connection. These properties can be updated after the resource has been created."]
2470#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2471pub struct NetworkConnectionUpdateProperties {
2472 #[doc = "The subnet to attach Virtual Machines to"]
2473 #[serde(rename = "subnetId", default, skip_serializing_if = "Option::is_none")]
2474 pub subnet_id: Option<String>,
2475 #[doc = "Active Directory domain name"]
2476 #[serde(rename = "domainName", default, skip_serializing_if = "Option::is_none")]
2477 pub domain_name: Option<String>,
2478 #[doc = "Active Directory domain Organization Unit (OU)"]
2479 #[serde(rename = "organizationUnit", default, skip_serializing_if = "Option::is_none")]
2480 pub organization_unit: Option<String>,
2481 #[doc = "The username of an Active Directory account (user or service account) that has permissions to create computer objects in Active Directory. Required format: admin@contoso.com."]
2482 #[serde(rename = "domainUsername", default, skip_serializing_if = "Option::is_none")]
2483 pub domain_username: Option<String>,
2484 #[doc = "The password for the account used to join domain"]
2485 #[serde(rename = "domainPassword", default, skip_serializing_if = "Option::is_none")]
2486 pub domain_password: Option<String>,
2487}
2488impl NetworkConnectionUpdateProperties {
2489 pub fn new() -> Self {
2490 Self::default()
2491 }
2492}
2493#[doc = "Network properties"]
2494#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2495pub struct NetworkProperties {
2496 #[serde(flatten)]
2497 pub network_connection_update_properties: NetworkConnectionUpdateProperties,
2498 #[doc = "Provisioning state of the resource."]
2499 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
2500 pub provisioning_state: Option<ProvisioningState>,
2501 #[doc = "Health check status values"]
2502 #[serde(rename = "healthCheckStatus", default, skip_serializing_if = "Option::is_none")]
2503 pub health_check_status: Option<HealthCheckStatus>,
2504 #[doc = "The name for resource group where NICs will be placed."]
2505 #[serde(rename = "networkingResourceGroupName", default, skip_serializing_if = "Option::is_none")]
2506 pub networking_resource_group_name: Option<String>,
2507 #[doc = "Active Directory join type"]
2508 #[serde(rename = "domainJoinType")]
2509 pub domain_join_type: DomainJoinType,
2510}
2511impl NetworkProperties {
2512 pub fn new(domain_join_type: DomainJoinType) -> Self {
2513 Self {
2514 network_connection_update_properties: NetworkConnectionUpdateProperties::default(),
2515 provisioning_state: None,
2516 health_check_status: None,
2517 networking_resource_group_name: None,
2518 domain_join_type,
2519 }
2520 }
2521}
2522#[doc = "Details of a REST API operation, returned from the Resource Provider Operations API"]
2523#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2524pub struct Operation {
2525 #[doc = "The name of the operation, as per Resource-Based Access Control (RBAC). Examples: \"Microsoft.Compute/virtualMachines/write\", \"Microsoft.Compute/virtualMachines/capture/action\""]
2526 #[serde(default, skip_serializing_if = "Option::is_none")]
2527 pub name: Option<String>,
2528 #[doc = "Whether the operation applies to data-plane. This is \"true\" for data-plane operations and \"false\" for ARM/control-plane operations."]
2529 #[serde(rename = "isDataAction", default, skip_serializing_if = "Option::is_none")]
2530 pub is_data_action: Option<bool>,
2531 #[doc = "Localized display information for this particular operation."]
2532 #[serde(default, skip_serializing_if = "Option::is_none")]
2533 pub display: Option<operation::Display>,
2534 #[doc = "The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is \"user,system\""]
2535 #[serde(default, skip_serializing_if = "Option::is_none")]
2536 pub origin: Option<operation::Origin>,
2537 #[doc = "Enum. Indicates the action type. \"Internal\" refers to actions that are for internal only APIs."]
2538 #[serde(rename = "actionType", default, skip_serializing_if = "Option::is_none")]
2539 pub action_type: Option<operation::ActionType>,
2540}
2541impl Operation {
2542 pub fn new() -> Self {
2543 Self::default()
2544 }
2545}
2546pub mod operation {
2547 use super::*;
2548 #[doc = "Localized display information for this particular operation."]
2549 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2550 pub struct Display {
2551 #[doc = "The localized friendly form of the resource provider name, e.g. \"Microsoft Monitoring Insights\" or \"Microsoft Compute\"."]
2552 #[serde(default, skip_serializing_if = "Option::is_none")]
2553 pub provider: Option<String>,
2554 #[doc = "The localized friendly name of the resource type related to this operation. E.g. \"Virtual Machines\" or \"Job Schedule Collections\"."]
2555 #[serde(default, skip_serializing_if = "Option::is_none")]
2556 pub resource: Option<String>,
2557 #[doc = "The concise, localized friendly name for the operation; suitable for dropdowns. E.g. \"Create or Update Virtual Machine\", \"Restart Virtual Machine\"."]
2558 #[serde(default, skip_serializing_if = "Option::is_none")]
2559 pub operation: Option<String>,
2560 #[doc = "The short, localized friendly description of the operation; suitable for tool tips and detailed views."]
2561 #[serde(default, skip_serializing_if = "Option::is_none")]
2562 pub description: Option<String>,
2563 }
2564 impl Display {
2565 pub fn new() -> Self {
2566 Self::default()
2567 }
2568 }
2569 #[doc = "The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is \"user,system\""]
2570 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2571 #[serde(remote = "Origin")]
2572 pub enum Origin {
2573 #[serde(rename = "user")]
2574 User,
2575 #[serde(rename = "system")]
2576 System,
2577 #[serde(rename = "user,system")]
2578 UserSystem,
2579 #[serde(skip_deserializing)]
2580 UnknownValue(String),
2581 }
2582 impl FromStr for Origin {
2583 type Err = value::Error;
2584 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
2585 Self::deserialize(s.into_deserializer())
2586 }
2587 }
2588 impl<'de> Deserialize<'de> for Origin {
2589 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2590 where
2591 D: Deserializer<'de>,
2592 {
2593 let s = String::deserialize(deserializer)?;
2594 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
2595 Ok(deserialized)
2596 }
2597 }
2598 impl Serialize for Origin {
2599 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2600 where
2601 S: Serializer,
2602 {
2603 match self {
2604 Self::User => serializer.serialize_unit_variant("Origin", 0u32, "user"),
2605 Self::System => serializer.serialize_unit_variant("Origin", 1u32, "system"),
2606 Self::UserSystem => serializer.serialize_unit_variant("Origin", 2u32, "user,system"),
2607 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
2608 }
2609 }
2610 }
2611 #[doc = "Enum. Indicates the action type. \"Internal\" refers to actions that are for internal only APIs."]
2612 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2613 #[serde(remote = "ActionType")]
2614 pub enum ActionType {
2615 Internal,
2616 #[serde(skip_deserializing)]
2617 UnknownValue(String),
2618 }
2619 impl FromStr for ActionType {
2620 type Err = value::Error;
2621 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
2622 Self::deserialize(s.into_deserializer())
2623 }
2624 }
2625 impl<'de> Deserialize<'de> for ActionType {
2626 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2627 where
2628 D: Deserializer<'de>,
2629 {
2630 let s = String::deserialize(deserializer)?;
2631 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
2632 Ok(deserialized)
2633 }
2634 }
2635 impl Serialize for ActionType {
2636 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2637 where
2638 S: Serializer,
2639 {
2640 match self {
2641 Self::Internal => serializer.serialize_unit_variant("ActionType", 0u32, "Internal"),
2642 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
2643 }
2644 }
2645 }
2646}
2647#[doc = "A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results."]
2648#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2649pub struct OperationListResult {
2650 #[doc = "List of operations supported by the resource provider"]
2651 #[serde(
2652 default,
2653 deserialize_with = "azure_core::util::deserialize_null_as_default",
2654 skip_serializing_if = "Vec::is_empty"
2655 )]
2656 pub value: Vec<Operation>,
2657 #[doc = "URL to get the next set of operation list results (if there are any)."]
2658 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
2659 pub next_link: Option<String>,
2660}
2661impl azure_core::Continuable for OperationListResult {
2662 type Continuation = String;
2663 fn continuation(&self) -> Option<Self::Continuation> {
2664 self.next_link.clone().filter(|value| !value.is_empty())
2665 }
2666}
2667impl OperationListResult {
2668 pub fn new() -> Self {
2669 Self::default()
2670 }
2671}
2672#[doc = "The current status of an async operation"]
2673#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2674pub struct OperationStatus {
2675 #[serde(flatten)]
2676 pub operation_status_result: OperationStatusResult,
2677 #[doc = "Custom operation properties, populated only for a successful operation."]
2678 #[serde(default, skip_serializing_if = "Option::is_none")]
2679 pub properties: Option<serde_json::Value>,
2680}
2681impl OperationStatus {
2682 pub fn new(operation_status_result: OperationStatusResult) -> Self {
2683 Self {
2684 operation_status_result,
2685 properties: None,
2686 }
2687 }
2688}
2689#[doc = "The current status of an async operation."]
2690#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2691pub struct OperationStatusResult {
2692 #[doc = "Fully qualified ID for the async operation."]
2693 #[serde(default, skip_serializing_if = "Option::is_none")]
2694 pub id: Option<String>,
2695 #[doc = "Fully qualified ID of the resource against which the original async operation was started."]
2696 #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
2697 pub resource_id: Option<String>,
2698 #[doc = "Name of the async operation."]
2699 #[serde(default, skip_serializing_if = "Option::is_none")]
2700 pub name: Option<String>,
2701 #[doc = "Operation status."]
2702 pub status: String,
2703 #[doc = "Percent of the operation that is complete."]
2704 #[serde(rename = "percentComplete", default, skip_serializing_if = "Option::is_none")]
2705 pub percent_complete: Option<f64>,
2706 #[doc = "The start time of the operation."]
2707 #[serde(rename = "startTime", default, with = "azure_core::date::rfc3339::option")]
2708 pub start_time: Option<::time::OffsetDateTime>,
2709 #[doc = "The end time of the operation."]
2710 #[serde(rename = "endTime", default, with = "azure_core::date::rfc3339::option")]
2711 pub end_time: Option<::time::OffsetDateTime>,
2712 #[doc = "The operations list."]
2713 #[serde(
2714 default,
2715 deserialize_with = "azure_core::util::deserialize_null_as_default",
2716 skip_serializing_if = "Vec::is_empty"
2717 )]
2718 pub operations: Vec<OperationStatusResult>,
2719 #[doc = "The error detail."]
2720 #[serde(default, skip_serializing_if = "Option::is_none")]
2721 pub error: Option<ErrorDetail>,
2722}
2723impl OperationStatusResult {
2724 pub fn new(status: String) -> Self {
2725 Self {
2726 id: None,
2727 resource_id: None,
2728 name: None,
2729 status,
2730 percent_complete: None,
2731 start_time: None,
2732 end_time: None,
2733 operations: Vec::new(),
2734 error: None,
2735 }
2736 }
2737}
2738#[doc = "A collection of related endpoints from the same service for which the agent requires outbound access."]
2739#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2740pub struct OutboundEnvironmentEndpoint {
2741 #[doc = "The type of service that the agent connects to."]
2742 #[serde(default, skip_serializing_if = "Option::is_none")]
2743 pub category: Option<String>,
2744 #[doc = "The endpoints for this service for which the agent requires outbound access."]
2745 #[serde(
2746 default,
2747 deserialize_with = "azure_core::util::deserialize_null_as_default",
2748 skip_serializing_if = "Vec::is_empty"
2749 )]
2750 pub endpoints: Vec<EndpointDependency>,
2751}
2752impl OutboundEnvironmentEndpoint {
2753 pub fn new() -> Self {
2754 Self::default()
2755 }
2756}
2757#[doc = "Values returned by the List operation."]
2758#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2759pub struct OutboundEnvironmentEndpointCollection {
2760 #[doc = "The collection of outbound network dependency endpoints returned by the listing operation."]
2761 #[serde(
2762 default,
2763 deserialize_with = "azure_core::util::deserialize_null_as_default",
2764 skip_serializing_if = "Vec::is_empty"
2765 )]
2766 pub value: Vec<OutboundEnvironmentEndpoint>,
2767 #[doc = "The continuation token."]
2768 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
2769 pub next_link: Option<String>,
2770}
2771impl azure_core::Continuable for OutboundEnvironmentEndpointCollection {
2772 type Continuation = String;
2773 fn continuation(&self) -> Option<Self::Continuation> {
2774 self.next_link.clone().filter(|value| !value.is_empty())
2775 }
2776}
2777impl OutboundEnvironmentEndpointCollection {
2778 pub fn new() -> Self {
2779 Self::default()
2780 }
2781}
2782#[doc = "The type of data a parameter accepts."]
2783#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2784#[serde(remote = "ParameterType")]
2785pub enum ParameterType {
2786 #[serde(rename = "array")]
2787 Array,
2788 #[serde(rename = "boolean")]
2789 Boolean,
2790 #[serde(rename = "integer")]
2791 Integer,
2792 #[serde(rename = "number")]
2793 Number,
2794 #[serde(rename = "object")]
2795 Object,
2796 #[serde(rename = "string")]
2797 String,
2798 #[serde(skip_deserializing)]
2799 UnknownValue(String),
2800}
2801impl FromStr for ParameterType {
2802 type Err = value::Error;
2803 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
2804 Self::deserialize(s.into_deserializer())
2805 }
2806}
2807impl<'de> Deserialize<'de> for ParameterType {
2808 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2809 where
2810 D: Deserializer<'de>,
2811 {
2812 let s = String::deserialize(deserializer)?;
2813 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
2814 Ok(deserialized)
2815 }
2816}
2817impl Serialize for ParameterType {
2818 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2819 where
2820 S: Serializer,
2821 {
2822 match self {
2823 Self::Array => serializer.serialize_unit_variant("ParameterType", 0u32, "array"),
2824 Self::Boolean => serializer.serialize_unit_variant("ParameterType", 1u32, "boolean"),
2825 Self::Integer => serializer.serialize_unit_variant("ParameterType", 2u32, "integer"),
2826 Self::Number => serializer.serialize_unit_variant("ParameterType", 3u32, "number"),
2827 Self::Object => serializer.serialize_unit_variant("ParameterType", 4u32, "object"),
2828 Self::String => serializer.serialize_unit_variant("ParameterType", 5u32, "string"),
2829 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
2830 }
2831 }
2832}
2833#[doc = "Result of the list devcenter plans operation"]
2834#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2835pub struct PlanListResult {
2836 #[doc = "Current page of results."]
2837 #[serde(
2838 default,
2839 deserialize_with = "azure_core::util::deserialize_null_as_default",
2840 skip_serializing_if = "Vec::is_empty"
2841 )]
2842 pub value: Vec<DevCenterPlan>,
2843 #[doc = "URL to get the next set of results if there are any."]
2844 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
2845 pub next_link: Option<String>,
2846}
2847impl azure_core::Continuable for PlanListResult {
2848 type Continuation = String;
2849 fn continuation(&self) -> Option<Self::Continuation> {
2850 self.next_link.clone().filter(|value| !value.is_empty())
2851 }
2852}
2853impl PlanListResult {
2854 pub fn new() -> Self {
2855 Self::default()
2856 }
2857}
2858#[doc = "Properties of the devcenter plan member."]
2859#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2860pub struct PlanMemberProperties {
2861 #[doc = "The unique id of the member."]
2862 #[serde(rename = "memberId", default, skip_serializing_if = "Option::is_none")]
2863 pub member_id: Option<String>,
2864 #[doc = "The type of the member (user, group)"]
2865 #[serde(rename = "memberType", default, skip_serializing_if = "Option::is_none")]
2866 pub member_type: Option<plan_member_properties::MemberType>,
2867 #[doc = "Resource tags."]
2868 #[serde(default, skip_serializing_if = "Option::is_none")]
2869 pub tags: Option<Tags>,
2870 #[doc = "Provisioning state of the resource."]
2871 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
2872 pub provisioning_state: Option<ProvisioningState>,
2873}
2874impl PlanMemberProperties {
2875 pub fn new() -> Self {
2876 Self::default()
2877 }
2878}
2879pub mod plan_member_properties {
2880 use super::*;
2881 #[doc = "The type of the member (user, group)"]
2882 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2883 #[serde(remote = "MemberType")]
2884 pub enum MemberType {
2885 User,
2886 Group,
2887 #[serde(skip_deserializing)]
2888 UnknownValue(String),
2889 }
2890 impl FromStr for MemberType {
2891 type Err = value::Error;
2892 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
2893 Self::deserialize(s.into_deserializer())
2894 }
2895 }
2896 impl<'de> Deserialize<'de> for MemberType {
2897 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2898 where
2899 D: Deserializer<'de>,
2900 {
2901 let s = String::deserialize(deserializer)?;
2902 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
2903 Ok(deserialized)
2904 }
2905 }
2906 impl Serialize for MemberType {
2907 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2908 where
2909 S: Serializer,
2910 {
2911 match self {
2912 Self::User => serializer.serialize_unit_variant("MemberType", 0u32, "User"),
2913 Self::Group => serializer.serialize_unit_variant("MemberType", 1u32, "Group"),
2914 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
2915 }
2916 }
2917 }
2918}
2919#[doc = "The devcenter plan member resource for partial updates. Properties not provided in the update request will not be changed."]
2920#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2921pub struct PlanMemberUpdate {
2922 #[doc = "Resource tags."]
2923 #[serde(default, skip_serializing_if = "Option::is_none")]
2924 pub tags: Option<Tags>,
2925}
2926impl PlanMemberUpdate {
2927 pub fn new() -> Self {
2928 Self::default()
2929 }
2930}
2931#[doc = "Result of the list devcenter plan members operation"]
2932#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2933pub struct PlanMembersListResult {
2934 #[doc = "Current page of results."]
2935 #[serde(
2936 default,
2937 deserialize_with = "azure_core::util::deserialize_null_as_default",
2938 skip_serializing_if = "Vec::is_empty"
2939 )]
2940 pub value: Vec<DevCenterPlanMember>,
2941 #[doc = "URL to get the next set of results if there are any."]
2942 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
2943 pub next_link: Option<String>,
2944}
2945impl azure_core::Continuable for PlanMembersListResult {
2946 type Continuation = String;
2947 fn continuation(&self) -> Option<Self::Continuation> {
2948 self.next_link.clone().filter(|value| !value.is_empty())
2949 }
2950}
2951impl PlanMembersListResult {
2952 pub fn new() -> Self {
2953 Self::default()
2954 }
2955}
2956#[doc = "Properties of the devcenter plan."]
2957#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2958pub struct PlanProperties {
2959 #[doc = "Provisioning state of the resource."]
2960 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
2961 pub provisioning_state: Option<ProvisioningState>,
2962}
2963impl PlanProperties {
2964 pub fn new() -> Self {
2965 Self::default()
2966 }
2967}
2968#[doc = "The devcenter plan resource for partial updates. Properties not provided in the update request will not be changed."]
2969#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2970pub struct PlanUpdate {
2971 #[serde(flatten)]
2972 pub tracked_resource_update: TrackedResourceUpdate,
2973 #[doc = "The resource model definition representing SKU"]
2974 #[serde(default, skip_serializing_if = "Option::is_none")]
2975 pub sku: Option<Sku>,
2976}
2977impl PlanUpdate {
2978 pub fn new() -> Self {
2979 Self::default()
2980 }
2981}
2982#[doc = "A pool of Virtual Machines."]
2983#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2984pub struct Pool {
2985 #[serde(flatten)]
2986 pub tracked_resource: TrackedResource,
2987 #[doc = "Properties of a Pool"]
2988 #[serde(default, skip_serializing_if = "Option::is_none")]
2989 pub properties: Option<PoolProperties>,
2990}
2991impl Pool {
2992 pub fn new(tracked_resource: TrackedResource) -> Self {
2993 Self {
2994 tracked_resource,
2995 properties: None,
2996 }
2997 }
2998}
2999#[doc = "Represents a definition for a Developer Machine."]
3000#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3001pub struct PoolDevBoxDefinition {
3002 #[doc = "Image reference information"]
3003 #[serde(rename = "imageReference", default, skip_serializing_if = "Option::is_none")]
3004 pub image_reference: Option<ImageReference>,
3005 #[doc = "The resource model definition representing SKU"]
3006 #[serde(default, skip_serializing_if = "Option::is_none")]
3007 pub sku: Option<Sku>,
3008 #[doc = "Image reference information"]
3009 #[serde(rename = "activeImageReference", default, skip_serializing_if = "Option::is_none")]
3010 pub active_image_reference: Option<ImageReference>,
3011}
3012impl PoolDevBoxDefinition {
3013 pub fn new() -> Self {
3014 Self::default()
3015 }
3016}
3017#[doc = "Indicates if the pool is created from an existing Dev Box Definition or if one is provided directly."]
3018#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3019#[serde(remote = "PoolDevBoxDefinitionType")]
3020pub enum PoolDevBoxDefinitionType {
3021 Reference,
3022 Value,
3023 #[serde(skip_deserializing)]
3024 UnknownValue(String),
3025}
3026impl FromStr for PoolDevBoxDefinitionType {
3027 type Err = value::Error;
3028 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
3029 Self::deserialize(s.into_deserializer())
3030 }
3031}
3032impl<'de> Deserialize<'de> for PoolDevBoxDefinitionType {
3033 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3034 where
3035 D: Deserializer<'de>,
3036 {
3037 let s = String::deserialize(deserializer)?;
3038 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
3039 Ok(deserialized)
3040 }
3041}
3042impl Serialize for PoolDevBoxDefinitionType {
3043 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3044 where
3045 S: Serializer,
3046 {
3047 match self {
3048 Self::Reference => serializer.serialize_unit_variant("PoolDevBoxDefinitionType", 0u32, "Reference"),
3049 Self::Value => serializer.serialize_unit_variant("PoolDevBoxDefinitionType", 1u32, "Value"),
3050 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
3051 }
3052 }
3053}
3054#[doc = "Results of the machine pool list operation."]
3055#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3056pub struct PoolListResult {
3057 #[doc = "Current page of results."]
3058 #[serde(
3059 default,
3060 deserialize_with = "azure_core::util::deserialize_null_as_default",
3061 skip_serializing_if = "Vec::is_empty"
3062 )]
3063 pub value: Vec<Pool>,
3064 #[doc = "URL to get the next set of results if there are any."]
3065 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
3066 pub next_link: Option<String>,
3067}
3068impl azure_core::Continuable for PoolListResult {
3069 type Continuation = String;
3070 fn continuation(&self) -> Option<Self::Continuation> {
3071 self.next_link.clone().filter(|value| !value.is_empty())
3072 }
3073}
3074impl PoolListResult {
3075 pub fn new() -> Self {
3076 Self::default()
3077 }
3078}
3079#[doc = "Properties of a Pool"]
3080#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3081pub struct PoolProperties {
3082 #[serde(flatten)]
3083 pub pool_update_properties: PoolUpdateProperties,
3084 #[doc = "Health status indicating whether a pool is available to create Dev Boxes."]
3085 #[serde(rename = "healthStatus", default, skip_serializing_if = "Option::is_none")]
3086 pub health_status: Option<HealthStatus>,
3087 #[doc = "Details on the Pool health status to help diagnose issues. This is only populated when the pool status indicates the pool is in a non-healthy state"]
3088 #[serde(
3089 rename = "healthStatusDetails",
3090 default,
3091 deserialize_with = "azure_core::util::deserialize_null_as_default",
3092 skip_serializing_if = "Vec::is_empty"
3093 )]
3094 pub health_status_details: Vec<HealthStatusDetail>,
3095 #[doc = "Indicates the number of provisioned Dev Boxes in this pool."]
3096 #[serde(rename = "devBoxCount", default, skip_serializing_if = "Option::is_none")]
3097 pub dev_box_count: Option<i32>,
3098 #[doc = "Provisioning state of the resource."]
3099 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
3100 pub provisioning_state: Option<ProvisioningState>,
3101}
3102impl PoolProperties {
3103 pub fn new() -> Self {
3104 Self {
3105 pool_update_properties: PoolUpdateProperties::default(),
3106 health_status: None,
3107 health_status_details: Vec::new(),
3108 dev_box_count: None,
3109 provisioning_state: None,
3110 }
3111 }
3112}
3113#[doc = "The pool properties for partial update. Properties not provided in the update request will not be changed."]
3114#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3115pub struct PoolUpdate {
3116 #[serde(flatten)]
3117 pub tracked_resource_update: TrackedResourceUpdate,
3118 #[doc = "Properties of a Pool. These properties can be updated after the resource has been created."]
3119 #[serde(default, skip_serializing_if = "Option::is_none")]
3120 pub properties: Option<PoolUpdateProperties>,
3121}
3122impl PoolUpdate {
3123 pub fn new() -> Self {
3124 Self::default()
3125 }
3126}
3127#[doc = "Properties of a Pool. These properties can be updated after the resource has been created."]
3128#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3129pub struct PoolUpdateProperties {
3130 #[doc = "Indicates if the pool is created from an existing Dev Box Definition or if one is provided directly."]
3131 #[serde(rename = "devBoxDefinitionType", default, skip_serializing_if = "Option::is_none")]
3132 pub dev_box_definition_type: Option<PoolDevBoxDefinitionType>,
3133 #[doc = "Name of a Dev Box definition in parent Project of this Pool. Will be ignored if devBoxDefinitionType is Value."]
3134 #[serde(rename = "devBoxDefinitionName", default, skip_serializing_if = "Option::is_none")]
3135 pub dev_box_definition_name: Option<String>,
3136 #[doc = "Represents a definition for a Developer Machine."]
3137 #[serde(rename = "devBoxDefinition", default, skip_serializing_if = "Option::is_none")]
3138 pub dev_box_definition: Option<PoolDevBoxDefinition>,
3139 #[doc = "Name of a Network Connection in parent Project of this Pool"]
3140 #[serde(rename = "networkConnectionName", default, skip_serializing_if = "Option::is_none")]
3141 pub network_connection_name: Option<String>,
3142 #[doc = "License Types"]
3143 #[serde(rename = "licenseType", default, skip_serializing_if = "Option::is_none")]
3144 pub license_type: Option<LicenseType>,
3145 #[doc = "Local Administrator enable or disable status. Indicates whether owners of Dev Boxes are added as local administrators on the Dev Box."]
3146 #[serde(rename = "localAdministrator", default, skip_serializing_if = "Option::is_none")]
3147 pub local_administrator: Option<LocalAdminStatus>,
3148 #[doc = "Stop on disconnect configuration settings for Dev Boxes created in this pool."]
3149 #[serde(rename = "stopOnDisconnect", default, skip_serializing_if = "Option::is_none")]
3150 pub stop_on_disconnect: Option<StopOnDisconnectConfiguration>,
3151 #[doc = "SingleSignOn (SSO) enable or disable status. Indicates whether Dev Boxes in the Pool will have SSO enabled or disabled."]
3152 #[serde(rename = "singleSignOnStatus", default, skip_serializing_if = "Option::is_none")]
3153 pub single_sign_on_status: Option<SingleSignOnStatus>,
3154 #[doc = "The display name of the pool."]
3155 #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
3156 pub display_name: Option<String>,
3157 #[doc = "Indicates a pool uses a Virtual Network managed by Microsoft (Managed), or a customer provided Network (Unmanaged)."]
3158 #[serde(rename = "virtualNetworkType", default, skip_serializing_if = "Option::is_none")]
3159 pub virtual_network_type: Option<VirtualNetworkType>,
3160 #[doc = "The regions of the managed virtual network (required when managedNetworkType is Managed)."]
3161 #[serde(
3162 rename = "managedVirtualNetworkRegions",
3163 default,
3164 deserialize_with = "azure_core::util::deserialize_null_as_default",
3165 skip_serializing_if = "Vec::is_empty"
3166 )]
3167 pub managed_virtual_network_regions: Vec<String>,
3168}
3169impl PoolUpdateProperties {
3170 pub fn new() -> Self {
3171 Self::default()
3172 }
3173}
3174#[doc = "Represents a project resource."]
3175#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3176pub struct Project {
3177 #[serde(flatten)]
3178 pub tracked_resource: TrackedResource,
3179 #[doc = "Properties of a project."]
3180 #[serde(default, skip_serializing_if = "Option::is_none")]
3181 pub properties: Option<ProjectProperties>,
3182 #[doc = "Managed service identity (system assigned and/or user assigned identities)"]
3183 #[serde(default, skip_serializing_if = "Option::is_none")]
3184 pub identity: Option<ManagedServiceIdentity>,
3185}
3186impl Project {
3187 pub fn new(tracked_resource: TrackedResource) -> Self {
3188 Self {
3189 tracked_resource,
3190 properties: None,
3191 identity: None,
3192 }
3193 }
3194}
3195#[doc = "Settings to be used when associating a project with a catalog."]
3196#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3197pub struct ProjectCatalogSettings {
3198 #[doc = "Indicates catalog item types that can be synced."]
3199 #[serde(
3200 rename = "catalogItemSyncTypes",
3201 default,
3202 deserialize_with = "azure_core::util::deserialize_null_as_default",
3203 skip_serializing_if = "Vec::is_empty"
3204 )]
3205 pub catalog_item_sync_types: Vec<CatalogItemType>,
3206}
3207impl ProjectCatalogSettings {
3208 pub fn new() -> Self {
3209 Self::default()
3210 }
3211}
3212#[doc = "Represents an environment type."]
3213#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3214pub struct ProjectEnvironmentType {
3215 #[serde(flatten)]
3216 pub resource: Resource,
3217 #[doc = "Properties of a project environment type."]
3218 #[serde(default, skip_serializing_if = "Option::is_none")]
3219 pub properties: Option<ProjectEnvironmentTypeProperties>,
3220 #[doc = "Resource tags."]
3221 #[serde(default, skip_serializing_if = "Option::is_none")]
3222 pub tags: Option<Tags>,
3223 #[doc = "Managed service identity (system assigned and/or user assigned identities)"]
3224 #[serde(default, skip_serializing_if = "Option::is_none")]
3225 pub identity: Option<ManagedServiceIdentity>,
3226 #[doc = "The geo-location for the environment type"]
3227 #[serde(default, skip_serializing_if = "Option::is_none")]
3228 pub location: Option<String>,
3229}
3230impl ProjectEnvironmentType {
3231 pub fn new() -> Self {
3232 Self::default()
3233 }
3234}
3235#[doc = "Result of the project environment type list operation."]
3236#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3237pub struct ProjectEnvironmentTypeListResult {
3238 #[doc = "Current page of results."]
3239 #[serde(
3240 default,
3241 deserialize_with = "azure_core::util::deserialize_null_as_default",
3242 skip_serializing_if = "Vec::is_empty"
3243 )]
3244 pub value: Vec<ProjectEnvironmentType>,
3245 #[doc = "URL to get the next set of results if there are any."]
3246 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
3247 pub next_link: Option<String>,
3248}
3249impl azure_core::Continuable for ProjectEnvironmentTypeListResult {
3250 type Continuation = String;
3251 fn continuation(&self) -> Option<Self::Continuation> {
3252 self.next_link.clone().filter(|value| !value.is_empty())
3253 }
3254}
3255impl ProjectEnvironmentTypeListResult {
3256 pub fn new() -> Self {
3257 Self::default()
3258 }
3259}
3260#[doc = "Properties of a project environment type."]
3261#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3262pub struct ProjectEnvironmentTypeProperties {
3263 #[serde(flatten)]
3264 pub project_environment_type_update_properties: ProjectEnvironmentTypeUpdateProperties,
3265 #[doc = "Provisioning state of the resource."]
3266 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
3267 pub provisioning_state: Option<ProvisioningState>,
3268 #[doc = "The number of environments of this type."]
3269 #[serde(rename = "environmentCount", default, skip_serializing_if = "Option::is_none")]
3270 pub environment_count: Option<i32>,
3271}
3272impl ProjectEnvironmentTypeProperties {
3273 pub fn new() -> Self {
3274 Self::default()
3275 }
3276}
3277#[doc = "The project environment type for partial update. Properties not provided in the update request will not be changed."]
3278#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3279pub struct ProjectEnvironmentTypeUpdate {
3280 #[doc = "Properties of a project environment type. These properties can be updated after the resource has been created."]
3281 #[serde(default, skip_serializing_if = "Option::is_none")]
3282 pub properties: Option<ProjectEnvironmentTypeUpdateProperties>,
3283 #[doc = "Resource tags."]
3284 #[serde(default, skip_serializing_if = "Option::is_none")]
3285 pub tags: Option<Tags>,
3286 #[doc = "Managed service identity (system assigned and/or user assigned identities)"]
3287 #[serde(default, skip_serializing_if = "Option::is_none")]
3288 pub identity: Option<ManagedServiceIdentity>,
3289}
3290impl ProjectEnvironmentTypeUpdate {
3291 pub fn new() -> Self {
3292 Self::default()
3293 }
3294}
3295#[doc = "Properties of a project environment type. These properties can be updated after the resource has been created."]
3296#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3297pub struct ProjectEnvironmentTypeUpdateProperties {
3298 #[doc = "Id of a subscription that the environment type will be mapped to. The environment's resources will be deployed into this subscription."]
3299 #[serde(rename = "deploymentTargetId", default, skip_serializing_if = "Option::is_none")]
3300 pub deployment_target_id: Option<String>,
3301 #[doc = "The display name of the project environment type."]
3302 #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
3303 pub display_name: Option<String>,
3304 #[doc = "Indicates whether the environment type is either enabled or disabled."]
3305 #[serde(default, skip_serializing_if = "Option::is_none")]
3306 pub status: Option<EnvironmentTypeEnableStatus>,
3307 #[doc = "The role definition assigned to the environment creator on backing resources."]
3308 #[serde(rename = "creatorRoleAssignment", default, skip_serializing_if = "Option::is_none")]
3309 pub creator_role_assignment: Option<project_environment_type_update_properties::CreatorRoleAssignment>,
3310 #[doc = "Role Assignments created on environment backing resources. This is a mapping from a user object ID to an object of role definition IDs."]
3311 #[serde(rename = "userRoleAssignments", default, skip_serializing_if = "Option::is_none")]
3312 pub user_role_assignments: Option<serde_json::Value>,
3313}
3314impl ProjectEnvironmentTypeUpdateProperties {
3315 pub fn new() -> Self {
3316 Self::default()
3317 }
3318}
3319pub mod project_environment_type_update_properties {
3320 use super::*;
3321 #[doc = "The role definition assigned to the environment creator on backing resources."]
3322 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3323 pub struct CreatorRoleAssignment {
3324 #[doc = "A map of roles to assign to the environment creator."]
3325 #[serde(default, skip_serializing_if = "Option::is_none")]
3326 pub roles: Option<serde_json::Value>,
3327 }
3328 impl CreatorRoleAssignment {
3329 pub fn new() -> Self {
3330 Self::default()
3331 }
3332 }
3333}
3334#[doc = "Results of the project list operation."]
3335#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3336pub struct ProjectListResult {
3337 #[doc = "Current page of results."]
3338 #[serde(
3339 default,
3340 deserialize_with = "azure_core::util::deserialize_null_as_default",
3341 skip_serializing_if = "Vec::is_empty"
3342 )]
3343 pub value: Vec<Project>,
3344 #[doc = "URL to get the next set of results if there are any."]
3345 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
3346 pub next_link: Option<String>,
3347}
3348impl azure_core::Continuable for ProjectListResult {
3349 type Continuation = String;
3350 fn continuation(&self) -> Option<Self::Continuation> {
3351 self.next_link.clone().filter(|value| !value.is_empty())
3352 }
3353}
3354impl ProjectListResult {
3355 pub fn new() -> Self {
3356 Self::default()
3357 }
3358}
3359#[doc = "Network settings for the project."]
3360#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3361pub struct ProjectNetworkSettings {
3362 #[doc = "Indicates whether pools in this Dev Center can use Microsoft Hosted Networks. Defaults to Enabled if not set."]
3363 #[serde(rename = "microsoftHostedNetworkEnableStatus", default, skip_serializing_if = "Option::is_none")]
3364 pub microsoft_hosted_network_enable_status: Option<MicrosoftHostedNetworkEnableStatus>,
3365}
3366impl ProjectNetworkSettings {
3367 pub fn new() -> Self {
3368 Self::default()
3369 }
3370}
3371#[doc = "Properties of a project."]
3372#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3373pub struct ProjectProperties {
3374 #[serde(flatten)]
3375 pub project_update_properties: ProjectUpdateProperties,
3376 #[doc = "Provisioning state of the resource."]
3377 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
3378 pub provisioning_state: Option<ProvisioningState>,
3379 #[doc = "The URI of the resource."]
3380 #[serde(rename = "devCenterUri", default, skip_serializing_if = "Option::is_none")]
3381 pub dev_center_uri: Option<DevCenterUri>,
3382}
3383impl ProjectProperties {
3384 pub fn new() -> Self {
3385 Self::default()
3386 }
3387}
3388#[doc = "The project properties for partial update. Properties not provided in the update request will not be changed."]
3389#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3390pub struct ProjectUpdate {
3391 #[serde(flatten)]
3392 pub tracked_resource_update: TrackedResourceUpdate,
3393 #[doc = "Properties of a project. These properties can be updated after the resource has been created."]
3394 #[serde(default, skip_serializing_if = "Option::is_none")]
3395 pub properties: Option<ProjectUpdateProperties>,
3396 #[doc = "Managed service identity (system assigned and/or user assigned identities)"]
3397 #[serde(default, skip_serializing_if = "Option::is_none")]
3398 pub identity: Option<ManagedServiceIdentity>,
3399}
3400impl ProjectUpdate {
3401 pub fn new() -> Self {
3402 Self::default()
3403 }
3404}
3405#[doc = "Properties of a project. These properties can be updated after the resource has been created."]
3406#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3407pub struct ProjectUpdateProperties {
3408 #[doc = "Resource Id of an associated DevCenter"]
3409 #[serde(rename = "devCenterId", default, skip_serializing_if = "Option::is_none")]
3410 pub dev_center_id: Option<String>,
3411 #[doc = "Description of the project."]
3412 #[serde(default, skip_serializing_if = "Option::is_none")]
3413 pub description: Option<String>,
3414 #[doc = "When specified, limits the maximum number of Dev Boxes a single user can create across all pools in the project. This will have no effect on existing Dev Boxes when reduced."]
3415 #[serde(rename = "maxDevBoxesPerUser", default, skip_serializing_if = "Option::is_none")]
3416 pub max_dev_boxes_per_user: Option<i32>,
3417 #[doc = "The display name of the project."]
3418 #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
3419 pub display_name: Option<String>,
3420 #[doc = "Settings to be used when associating a project with a catalog."]
3421 #[serde(rename = "catalogSettings", default, skip_serializing_if = "Option::is_none")]
3422 pub catalog_settings: Option<ProjectCatalogSettings>,
3423}
3424impl ProjectUpdateProperties {
3425 pub fn new() -> Self {
3426 Self::default()
3427 }
3428}
3429#[doc = "Provisioning state of the resource."]
3430#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3431#[serde(remote = "ProvisioningState")]
3432pub enum ProvisioningState {
3433 NotSpecified,
3434 Accepted,
3435 Running,
3436 Creating,
3437 Created,
3438 Updating,
3439 Updated,
3440 Deleting,
3441 Deleted,
3442 Succeeded,
3443 Failed,
3444 Canceled,
3445 MovingResources,
3446 TransientFailure,
3447 RolloutInProgress,
3448 StorageProvisioningFailed,
3449 #[serde(skip_deserializing)]
3450 UnknownValue(String),
3451}
3452impl FromStr for ProvisioningState {
3453 type Err = value::Error;
3454 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
3455 Self::deserialize(s.into_deserializer())
3456 }
3457}
3458impl<'de> Deserialize<'de> for ProvisioningState {
3459 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3460 where
3461 D: Deserializer<'de>,
3462 {
3463 let s = String::deserialize(deserializer)?;
3464 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
3465 Ok(deserialized)
3466 }
3467}
3468impl Serialize for ProvisioningState {
3469 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3470 where
3471 S: Serializer,
3472 {
3473 match self {
3474 Self::NotSpecified => serializer.serialize_unit_variant("ProvisioningState", 0u32, "NotSpecified"),
3475 Self::Accepted => serializer.serialize_unit_variant("ProvisioningState", 1u32, "Accepted"),
3476 Self::Running => serializer.serialize_unit_variant("ProvisioningState", 2u32, "Running"),
3477 Self::Creating => serializer.serialize_unit_variant("ProvisioningState", 3u32, "Creating"),
3478 Self::Created => serializer.serialize_unit_variant("ProvisioningState", 4u32, "Created"),
3479 Self::Updating => serializer.serialize_unit_variant("ProvisioningState", 5u32, "Updating"),
3480 Self::Updated => serializer.serialize_unit_variant("ProvisioningState", 6u32, "Updated"),
3481 Self::Deleting => serializer.serialize_unit_variant("ProvisioningState", 7u32, "Deleting"),
3482 Self::Deleted => serializer.serialize_unit_variant("ProvisioningState", 8u32, "Deleted"),
3483 Self::Succeeded => serializer.serialize_unit_variant("ProvisioningState", 9u32, "Succeeded"),
3484 Self::Failed => serializer.serialize_unit_variant("ProvisioningState", 10u32, "Failed"),
3485 Self::Canceled => serializer.serialize_unit_variant("ProvisioningState", 11u32, "Canceled"),
3486 Self::MovingResources => serializer.serialize_unit_variant("ProvisioningState", 12u32, "MovingResources"),
3487 Self::TransientFailure => serializer.serialize_unit_variant("ProvisioningState", 13u32, "TransientFailure"),
3488 Self::RolloutInProgress => serializer.serialize_unit_variant("ProvisioningState", 14u32, "RolloutInProgress"),
3489 Self::StorageProvisioningFailed => serializer.serialize_unit_variant("ProvisioningState", 15u32, "StorageProvisioningFailed"),
3490 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
3491 }
3492 }
3493}
3494#[doc = "The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location"]
3495#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3496pub struct ProxyResource {
3497 #[serde(flatten)]
3498 pub resource: Resource,
3499}
3500impl ProxyResource {
3501 pub fn new() -> Self {
3502 Self::default()
3503 }
3504}
3505#[doc = "Properties for a recommended machine configuration."]
3506#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3507pub struct RecommendedMachineConfiguration {
3508 #[doc = "Properties for a range of values."]
3509 #[serde(default, skip_serializing_if = "Option::is_none")]
3510 pub memory: Option<ResourceRange>,
3511 #[doc = "Properties for a range of values."]
3512 #[serde(rename = "vCPUs", default, skip_serializing_if = "Option::is_none")]
3513 pub v_cp_us: Option<ResourceRange>,
3514}
3515impl RecommendedMachineConfiguration {
3516 pub fn new() -> Self {
3517 Self::default()
3518 }
3519}
3520#[doc = "Common fields that are returned in the response for all Azure Resource Manager resources"]
3521#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3522pub struct Resource {
3523 #[doc = "Fully qualified resource ID for the resource. E.g. \"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}\""]
3524 #[serde(default, skip_serializing_if = "Option::is_none")]
3525 pub id: Option<String>,
3526 #[doc = "The name of the resource"]
3527 #[serde(default, skip_serializing_if = "Option::is_none")]
3528 pub name: Option<String>,
3529 #[doc = "The type of the resource. E.g. \"Microsoft.Compute/virtualMachines\" or \"Microsoft.Storage/storageAccounts\""]
3530 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
3531 pub type_: Option<String>,
3532 #[doc = "Metadata pertaining to creation and last modification of the resource."]
3533 #[serde(rename = "systemData", default, skip_serializing_if = "Option::is_none")]
3534 pub system_data: Option<SystemData>,
3535}
3536impl Resource {
3537 pub fn new() -> Self {
3538 Self::default()
3539 }
3540}
3541#[doc = "Properties for a range of values."]
3542#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3543pub struct ResourceRange {
3544 #[doc = "Minimum value."]
3545 #[serde(default, skip_serializing_if = "Option::is_none")]
3546 pub min: Option<i32>,
3547 #[doc = "Maximum value."]
3548 #[serde(default, skip_serializing_if = "Option::is_none")]
3549 pub max: Option<i32>,
3550}
3551impl ResourceRange {
3552 pub fn new() -> Self {
3553 Self::default()
3554 }
3555}
3556#[doc = "Represents a Schedule to execute a task."]
3557#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3558pub struct Schedule {
3559 #[serde(flatten)]
3560 pub resource: Resource,
3561 #[doc = "The Schedule properties defining when and what to execute."]
3562 #[serde(default, skip_serializing_if = "Option::is_none")]
3563 pub properties: Option<ScheduleProperties>,
3564}
3565impl Schedule {
3566 pub fn new() -> Self {
3567 Self::default()
3568 }
3569}
3570#[doc = "Schedule enable or disable status. Indicates whether the schedule applied to is either enabled or disabled."]
3571#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3572#[serde(remote = "ScheduleEnableStatus")]
3573pub enum ScheduleEnableStatus {
3574 Enabled,
3575 Disabled,
3576 #[serde(skip_deserializing)]
3577 UnknownValue(String),
3578}
3579impl FromStr for ScheduleEnableStatus {
3580 type Err = value::Error;
3581 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
3582 Self::deserialize(s.into_deserializer())
3583 }
3584}
3585impl<'de> Deserialize<'de> for ScheduleEnableStatus {
3586 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3587 where
3588 D: Deserializer<'de>,
3589 {
3590 let s = String::deserialize(deserializer)?;
3591 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
3592 Ok(deserialized)
3593 }
3594}
3595impl Serialize for ScheduleEnableStatus {
3596 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3597 where
3598 S: Serializer,
3599 {
3600 match self {
3601 Self::Enabled => serializer.serialize_unit_variant("ScheduleEnableStatus", 0u32, "Enabled"),
3602 Self::Disabled => serializer.serialize_unit_variant("ScheduleEnableStatus", 1u32, "Disabled"),
3603 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
3604 }
3605 }
3606}
3607#[doc = "Result of the schedule list operation."]
3608#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3609pub struct ScheduleListResult {
3610 #[doc = "Current page of results."]
3611 #[serde(
3612 default,
3613 deserialize_with = "azure_core::util::deserialize_null_as_default",
3614 skip_serializing_if = "Vec::is_empty"
3615 )]
3616 pub value: Vec<Schedule>,
3617 #[doc = "URL to get the next set of results if there are any."]
3618 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
3619 pub next_link: Option<String>,
3620}
3621impl azure_core::Continuable for ScheduleListResult {
3622 type Continuation = String;
3623 fn continuation(&self) -> Option<Self::Continuation> {
3624 self.next_link.clone().filter(|value| !value.is_empty())
3625 }
3626}
3627impl ScheduleListResult {
3628 pub fn new() -> Self {
3629 Self::default()
3630 }
3631}
3632#[doc = "The Schedule properties defining when and what to execute."]
3633#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3634pub struct ScheduleProperties {
3635 #[serde(flatten)]
3636 pub schedule_update_properties: ScheduleUpdateProperties,
3637 #[doc = "Provisioning state of the resource."]
3638 #[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
3639 pub provisioning_state: Option<ProvisioningState>,
3640}
3641impl ScheduleProperties {
3642 pub fn new() -> Self {
3643 Self {
3644 schedule_update_properties: ScheduleUpdateProperties::default(),
3645 provisioning_state: None,
3646 }
3647 }
3648}
3649#[doc = "The schedule properties for partial update. Properties not provided in the update request will not be changed."]
3650#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3651pub struct ScheduleUpdate {
3652 #[doc = "Updatable properties of a Schedule."]
3653 #[serde(default, skip_serializing_if = "Option::is_none")]
3654 pub properties: Option<ScheduleUpdateProperties>,
3655}
3656impl ScheduleUpdate {
3657 pub fn new() -> Self {
3658 Self::default()
3659 }
3660}
3661#[doc = "Updatable properties of a Schedule."]
3662#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3663pub struct ScheduleUpdateProperties {
3664 #[serde(flatten)]
3665 pub tracked_resource_update: TrackedResourceUpdate,
3666 #[doc = "The supported types for a scheduled task."]
3667 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
3668 pub type_: Option<ScheduledType>,
3669 #[doc = "The frequency of task execution."]
3670 #[serde(default, skip_serializing_if = "Option::is_none")]
3671 pub frequency: Option<ScheduledFrequency>,
3672 #[doc = "The target time to trigger the action. The format is HH:MM."]
3673 #[serde(default, skip_serializing_if = "Option::is_none")]
3674 pub time: Option<String>,
3675 #[doc = "The IANA timezone id at which the schedule should execute."]
3676 #[serde(rename = "timeZone", default, skip_serializing_if = "Option::is_none")]
3677 pub time_zone: Option<String>,
3678 #[doc = "Schedule enable or disable status. Indicates whether the schedule applied to is either enabled or disabled."]
3679 #[serde(default, skip_serializing_if = "Option::is_none")]
3680 pub state: Option<ScheduleEnableStatus>,
3681}
3682impl ScheduleUpdateProperties {
3683 pub fn new() -> Self {
3684 Self::default()
3685 }
3686}
3687#[doc = "The frequency of task execution."]
3688#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3689#[serde(remote = "ScheduledFrequency")]
3690pub enum ScheduledFrequency {
3691 Daily,
3692 #[serde(skip_deserializing)]
3693 UnknownValue(String),
3694}
3695impl FromStr for ScheduledFrequency {
3696 type Err = value::Error;
3697 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
3698 Self::deserialize(s.into_deserializer())
3699 }
3700}
3701impl<'de> Deserialize<'de> for ScheduledFrequency {
3702 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3703 where
3704 D: Deserializer<'de>,
3705 {
3706 let s = String::deserialize(deserializer)?;
3707 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
3708 Ok(deserialized)
3709 }
3710}
3711impl Serialize for ScheduledFrequency {
3712 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3713 where
3714 S: Serializer,
3715 {
3716 match self {
3717 Self::Daily => serializer.serialize_unit_variant("ScheduledFrequency", 0u32, "Daily"),
3718 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
3719 }
3720 }
3721}
3722#[doc = "The supported types for a scheduled task."]
3723#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3724#[serde(remote = "ScheduledType")]
3725pub enum ScheduledType {
3726 StopDevBox,
3727 #[serde(skip_deserializing)]
3728 UnknownValue(String),
3729}
3730impl FromStr for ScheduledType {
3731 type Err = value::Error;
3732 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
3733 Self::deserialize(s.into_deserializer())
3734 }
3735}
3736impl<'de> Deserialize<'de> for ScheduledType {
3737 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3738 where
3739 D: Deserializer<'de>,
3740 {
3741 let s = String::deserialize(deserializer)?;
3742 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
3743 Ok(deserialized)
3744 }
3745}
3746impl Serialize for ScheduledType {
3747 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3748 where
3749 S: Serializer,
3750 {
3751 match self {
3752 Self::StopDevBox => serializer.serialize_unit_variant("ScheduledType", 0u32, "StopDevBox"),
3753 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
3754 }
3755 }
3756}
3757#[doc = "SingleSignOn (SSO) enable or disable status. Indicates whether Dev Boxes in the Pool will have SSO enabled or disabled."]
3758#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3759#[serde(remote = "SingleSignOnStatus")]
3760pub enum SingleSignOnStatus {
3761 Disabled,
3762 Enabled,
3763 #[serde(skip_deserializing)]
3764 UnknownValue(String),
3765}
3766impl FromStr for SingleSignOnStatus {
3767 type Err = value::Error;
3768 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
3769 Self::deserialize(s.into_deserializer())
3770 }
3771}
3772impl<'de> Deserialize<'de> for SingleSignOnStatus {
3773 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3774 where
3775 D: Deserializer<'de>,
3776 {
3777 let s = String::deserialize(deserializer)?;
3778 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
3779 Ok(deserialized)
3780 }
3781}
3782impl Serialize for SingleSignOnStatus {
3783 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3784 where
3785 S: Serializer,
3786 {
3787 match self {
3788 Self::Disabled => serializer.serialize_unit_variant("SingleSignOnStatus", 0u32, "Disabled"),
3789 Self::Enabled => serializer.serialize_unit_variant("SingleSignOnStatus", 1u32, "Enabled"),
3790 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
3791 }
3792 }
3793}
3794#[doc = "The resource model definition representing SKU"]
3795#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3796pub struct Sku {
3797 #[doc = "The name of the SKU. E.g. P3. It is typically a letter+number code"]
3798 pub name: String,
3799 #[doc = "This field is required to be implemented by the Resource Provider if the service has more than one tier, but is not required on a PUT."]
3800 #[serde(default, skip_serializing_if = "Option::is_none")]
3801 pub tier: Option<SkuTier>,
3802 #[doc = "The SKU size. When the name field is the combination of tier and some other value, this would be the standalone code. "]
3803 #[serde(default, skip_serializing_if = "Option::is_none")]
3804 pub size: Option<String>,
3805 #[doc = "If the service has different generations of hardware, for the same SKU, then that can be captured here."]
3806 #[serde(default, skip_serializing_if = "Option::is_none")]
3807 pub family: Option<String>,
3808 #[doc = "If the SKU supports scale out/in then the capacity integer should be included. If scale out/in is not possible for the resource this may be omitted."]
3809 #[serde(default, skip_serializing_if = "Option::is_none")]
3810 pub capacity: Option<i32>,
3811}
3812impl Sku {
3813 pub fn new(name: String) -> Self {
3814 Self {
3815 name,
3816 tier: None,
3817 size: None,
3818 family: None,
3819 capacity: None,
3820 }
3821 }
3822}
3823#[doc = "Results of the Microsoft.DevCenter SKU list operation."]
3824#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3825pub struct SkuListResult {
3826 #[doc = "Current page of results."]
3827 #[serde(
3828 default,
3829 deserialize_with = "azure_core::util::deserialize_null_as_default",
3830 skip_serializing_if = "Vec::is_empty"
3831 )]
3832 pub value: Vec<DevCenterSku>,
3833 #[doc = "URL to get the next set of results if there are any."]
3834 #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
3835 pub next_link: Option<String>,
3836}
3837impl azure_core::Continuable for SkuListResult {
3838 type Continuation = String;
3839 fn continuation(&self) -> Option<Self::Continuation> {
3840 self.next_link.clone().filter(|value| !value.is_empty())
3841 }
3842}
3843impl SkuListResult {
3844 pub fn new() -> Self {
3845 Self::default()
3846 }
3847}
3848#[doc = "This field is required to be implemented by the Resource Provider if the service has more than one tier, but is not required on a PUT."]
3849#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3850pub enum SkuTier {
3851 Free,
3852 Basic,
3853 Standard,
3854 Premium,
3855}
3856#[doc = "Stop on disconnect configuration settings for Dev Boxes created in this pool."]
3857#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3858pub struct StopOnDisconnectConfiguration {
3859 #[doc = "Stop on disconnect enable or disable status. Indicates whether stop on disconnect to is either enabled or disabled."]
3860 #[serde(default, skip_serializing_if = "Option::is_none")]
3861 pub status: Option<StopOnDisconnectEnableStatus>,
3862 #[doc = "The specified time in minutes to wait before stopping a Dev Box once disconnect is detected."]
3863 #[serde(rename = "gracePeriodMinutes", default, skip_serializing_if = "Option::is_none")]
3864 pub grace_period_minutes: Option<i32>,
3865}
3866impl StopOnDisconnectConfiguration {
3867 pub fn new() -> Self {
3868 Self::default()
3869 }
3870}
3871#[doc = "Stop on disconnect enable or disable status. Indicates whether stop on disconnect to is either enabled or disabled."]
3872#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3873#[serde(remote = "StopOnDisconnectEnableStatus")]
3874pub enum StopOnDisconnectEnableStatus {
3875 Enabled,
3876 Disabled,
3877 #[serde(skip_deserializing)]
3878 UnknownValue(String),
3879}
3880impl FromStr for StopOnDisconnectEnableStatus {
3881 type Err = value::Error;
3882 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
3883 Self::deserialize(s.into_deserializer())
3884 }
3885}
3886impl<'de> Deserialize<'de> for StopOnDisconnectEnableStatus {
3887 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3888 where
3889 D: Deserializer<'de>,
3890 {
3891 let s = String::deserialize(deserializer)?;
3892 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
3893 Ok(deserialized)
3894 }
3895}
3896impl Serialize for StopOnDisconnectEnableStatus {
3897 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3898 where
3899 S: Serializer,
3900 {
3901 match self {
3902 Self::Enabled => serializer.serialize_unit_variant("StopOnDisconnectEnableStatus", 0u32, "Enabled"),
3903 Self::Disabled => serializer.serialize_unit_variant("StopOnDisconnectEnableStatus", 1u32, "Disabled"),
3904 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
3905 }
3906 }
3907}
3908#[doc = "Synchronization error details."]
3909#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3910pub struct SyncErrorDetails {
3911 #[doc = "Catalog error details"]
3912 #[serde(rename = "operationError", default, skip_serializing_if = "Option::is_none")]
3913 pub operation_error: Option<CatalogErrorDetails>,
3914 #[doc = "Catalog items that have conflicting names."]
3915 #[serde(
3916 default,
3917 deserialize_with = "azure_core::util::deserialize_null_as_default",
3918 skip_serializing_if = "Vec::is_empty"
3919 )]
3920 pub conflicts: Vec<CatalogConflictError>,
3921 #[doc = "Errors that occured during synchronization."]
3922 #[serde(
3923 default,
3924 deserialize_with = "azure_core::util::deserialize_null_as_default",
3925 skip_serializing_if = "Vec::is_empty"
3926 )]
3927 pub errors: Vec<CatalogSyncError>,
3928}
3929impl SyncErrorDetails {
3930 pub fn new() -> Self {
3931 Self::default()
3932 }
3933}
3934#[doc = "Stats of the synchronization."]
3935#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3936pub struct SyncStats {
3937 #[doc = "Count of catalog items added during synchronization."]
3938 #[serde(default, skip_serializing_if = "Option::is_none")]
3939 pub added: Option<i32>,
3940 #[doc = "Count of catalog items updated during synchronization."]
3941 #[serde(default, skip_serializing_if = "Option::is_none")]
3942 pub updated: Option<i32>,
3943 #[doc = "Count of catalog items that were unchanged during synchronization."]
3944 #[serde(default, skip_serializing_if = "Option::is_none")]
3945 pub unchanged: Option<i32>,
3946 #[doc = "Count of catalog items removed during synchronization."]
3947 #[serde(default, skip_serializing_if = "Option::is_none")]
3948 pub removed: Option<i32>,
3949 #[doc = "Count of catalog items that had validation errors during synchronization."]
3950 #[serde(rename = "validationErrors", default, skip_serializing_if = "Option::is_none")]
3951 pub validation_errors: Option<i32>,
3952 #[doc = "Count of synchronization errors that occured during synchronization."]
3953 #[serde(rename = "synchronizationErrors", default, skip_serializing_if = "Option::is_none")]
3954 pub synchronization_errors: Option<i32>,
3955 #[doc = "Indicates catalog item types that were synced."]
3956 #[serde(
3957 rename = "syncedCatalogItemTypes",
3958 default,
3959 deserialize_with = "azure_core::util::deserialize_null_as_default",
3960 skip_serializing_if = "Vec::is_empty"
3961 )]
3962 pub synced_catalog_item_types: Vec<CatalogItemType>,
3963}
3964impl SyncStats {
3965 pub fn new() -> Self {
3966 Self::default()
3967 }
3968}
3969#[doc = "Resource tags."]
3970#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3971pub struct Tags {}
3972impl Tags {
3973 pub fn new() -> Self {
3974 Self::default()
3975 }
3976}
3977#[doc = "The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location'"]
3978#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3979pub struct TrackedResource {
3980 #[serde(flatten)]
3981 pub resource: Resource,
3982 #[doc = "Resource tags."]
3983 #[serde(default, skip_serializing_if = "Option::is_none")]
3984 pub tags: Option<serde_json::Value>,
3985 #[doc = "The geo-location where the resource lives"]
3986 pub location: String,
3987}
3988impl TrackedResource {
3989 pub fn new(location: String) -> Self {
3990 Self {
3991 resource: Resource::default(),
3992 tags: None,
3993 location,
3994 }
3995 }
3996}
3997#[doc = "Base tracked resource type for PATCH updates"]
3998#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3999pub struct TrackedResourceUpdate {
4000 #[doc = "Resource tags."]
4001 #[serde(default, skip_serializing_if = "Option::is_none")]
4002 pub tags: Option<Tags>,
4003 #[doc = "The geo-location where the resource lives"]
4004 #[serde(default, skip_serializing_if = "Option::is_none")]
4005 pub location: Option<String>,
4006}
4007impl TrackedResourceUpdate {
4008 pub fn new() -> Self {
4009 Self::default()
4010 }
4011}
4012#[doc = "The core usage details."]
4013#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4014pub struct Usage {
4015 #[doc = "The current usage."]
4016 #[serde(rename = "currentValue", default, skip_serializing_if = "Option::is_none")]
4017 pub current_value: Option<i64>,
4018 #[doc = "The limit integer."]
4019 #[serde(default, skip_serializing_if = "Option::is_none")]
4020 pub limit: Option<i64>,
4021 #[doc = "The unit details."]
4022 #[serde(default, skip_serializing_if = "Option::is_none")]
4023 pub unit: Option<usage::Unit>,
4024 #[doc = "The Usage Names."]
4025 #[serde(default, skip_serializing_if = "Option::is_none")]
4026 pub name: Option<UsageName>,
4027 #[doc = "The fully qualified arm resource id."]
4028 #[serde(default, skip_serializing_if = "Option::is_none")]
4029 pub id: Option<String>,
4030}
4031impl Usage {
4032 pub fn new() -> Self {
4033 Self::default()
4034 }
4035}
4036pub mod usage {
4037 use super::*;
4038 #[doc = "The unit details."]
4039 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
4040 #[serde(remote = "Unit")]
4041 pub enum Unit {
4042 Count,
4043 #[serde(skip_deserializing)]
4044 UnknownValue(String),
4045 }
4046 impl FromStr for Unit {
4047 type Err = value::Error;
4048 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
4049 Self::deserialize(s.into_deserializer())
4050 }
4051 }
4052 impl<'de> Deserialize<'de> for Unit {
4053 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4054 where
4055 D: Deserializer<'de>,
4056 {
4057 let s = String::deserialize(deserializer)?;
4058 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
4059 Ok(deserialized)
4060 }
4061 }
4062 impl Serialize for Unit {
4063 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4064 where
4065 S: Serializer,
4066 {
4067 match self {
4068 Self::Count => serializer.serialize_unit_variant("Unit", 0u32, "Count"),
4069 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
4070 }
4071 }
4072 }
4073}
4074#[doc = "The Usage Names."]
4075#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4076pub struct UsageName {
4077 #[doc = "The localized name of the resource."]
4078 #[serde(rename = "localizedValue", default, skip_serializing_if = "Option::is_none")]
4079 pub localized_value: Option<String>,
4080 #[doc = "The name of the resource."]
4081 #[serde(default, skip_serializing_if = "Option::is_none")]
4082 pub value: Option<String>,
4083}
4084impl UsageName {
4085 pub fn new() -> Self {
4086 Self::default()
4087 }
4088}
4089#[doc = "The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM resource ids in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. The dictionary values can be empty objects ({}) in requests."]
4090#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4091pub struct UserAssignedIdentities {}
4092impl UserAssignedIdentities {
4093 pub fn new() -> Self {
4094 Self::default()
4095 }
4096}
4097#[doc = "User assigned identity properties"]
4098#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4099pub struct UserAssignedIdentity {
4100 #[doc = "The principal ID of the assigned identity."]
4101 #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
4102 pub principal_id: Option<String>,
4103 #[doc = "The client ID of the assigned identity."]
4104 #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
4105 pub client_id: Option<String>,
4106}
4107impl UserAssignedIdentity {
4108 pub fn new() -> Self {
4109 Self::default()
4110 }
4111}
4112#[doc = "Mapping of user object ID to role assignments."]
4113#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4114pub struct UserRoleAssignment {
4115 #[doc = "A map of roles to assign to the parent user."]
4116 #[serde(default, skip_serializing_if = "Option::is_none")]
4117 pub roles: Option<serde_json::Value>,
4118}
4119impl UserRoleAssignment {
4120 pub fn new() -> Self {
4121 Self::default()
4122 }
4123}
4124#[doc = "Indicates a pool uses a Virtual Network managed by Microsoft (Managed), or a customer provided Network (Unmanaged)."]
4125#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
4126#[serde(remote = "VirtualNetworkType")]
4127pub enum VirtualNetworkType {
4128 Managed,
4129 Unmanaged,
4130 #[serde(skip_deserializing)]
4131 UnknownValue(String),
4132}
4133impl FromStr for VirtualNetworkType {
4134 type Err = value::Error;
4135 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
4136 Self::deserialize(s.into_deserializer())
4137 }
4138}
4139impl<'de> Deserialize<'de> for VirtualNetworkType {
4140 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4141 where
4142 D: Deserializer<'de>,
4143 {
4144 let s = String::deserialize(deserializer)?;
4145 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
4146 Ok(deserialized)
4147 }
4148}
4149impl Serialize for VirtualNetworkType {
4150 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4151 where
4152 S: Serializer,
4153 {
4154 match self {
4155 Self::Managed => serializer.serialize_unit_variant("VirtualNetworkType", 0u32, "Managed"),
4156 Self::Unmanaged => serializer.serialize_unit_variant("VirtualNetworkType", 1u32, "Unmanaged"),
4157 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
4158 }
4159 }
4160}
4161#[doc = "All Customer-managed key encryption properties for the resource."]
4162#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4163pub struct CustomerManagedKeyEncryption {
4164 #[doc = "All identity configuration for Customer-managed key settings defining which identity should be used to auth to Key Vault."]
4165 #[serde(rename = "keyEncryptionKeyIdentity", default, skip_serializing_if = "Option::is_none")]
4166 pub key_encryption_key_identity: Option<customer_managed_key_encryption::KeyEncryptionKeyIdentity>,
4167 #[doc = "key encryption key Url, versioned or non-versioned. Ex: https://contosovault.vault.azure.net/keys/contosokek/562a4bb76b524a1493a6afe8e536ee78 or https://contosovault.vault.azure.net/keys/contosokek."]
4168 #[serde(rename = "keyEncryptionKeyUrl", default, skip_serializing_if = "Option::is_none")]
4169 pub key_encryption_key_url: Option<String>,
4170}
4171impl CustomerManagedKeyEncryption {
4172 pub fn new() -> Self {
4173 Self::default()
4174 }
4175}
4176pub mod customer_managed_key_encryption {
4177 use super::*;
4178 #[doc = "All identity configuration for Customer-managed key settings defining which identity should be used to auth to Key Vault."]
4179 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4180 pub struct KeyEncryptionKeyIdentity {
4181 #[doc = "Values can be systemAssignedIdentity or userAssignedIdentity"]
4182 #[serde(rename = "identityType", default, skip_serializing_if = "Option::is_none")]
4183 pub identity_type: Option<key_encryption_key_identity::IdentityType>,
4184 #[doc = "user assigned identity to use for accessing key encryption key Url. Ex: /subscriptions/fa5fc227-a624-475e-b696-cdd604c735bc/resourceGroups/<resource group>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myId. Mutually exclusive with identityType systemAssignedIdentity and delegatedResourceIdentity."]
4185 #[serde(rename = "userAssignedIdentityResourceId", default, skip_serializing_if = "Option::is_none")]
4186 pub user_assigned_identity_resource_id: Option<String>,
4187 #[doc = "delegated identity to use for accessing key encryption key Url. Ex: /subscriptions/fa5fc227-a624-475e-b696-cdd604c735bc/resourceGroups/<resource group>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myId. Mutually exclusive with identityType systemAssignedIdentity and userAssignedIdentity - internal use only."]
4188 #[serde(rename = "delegatedIdentityClientId", default, skip_serializing_if = "Option::is_none")]
4189 pub delegated_identity_client_id: Option<String>,
4190 }
4191 impl KeyEncryptionKeyIdentity {
4192 pub fn new() -> Self {
4193 Self::default()
4194 }
4195 }
4196 pub mod key_encryption_key_identity {
4197 use super::*;
4198 #[doc = "Values can be systemAssignedIdentity or userAssignedIdentity"]
4199 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
4200 #[serde(remote = "IdentityType")]
4201 pub enum IdentityType {
4202 #[serde(rename = "systemAssignedIdentity")]
4203 SystemAssignedIdentity,
4204 #[serde(rename = "userAssignedIdentity")]
4205 UserAssignedIdentity,
4206 #[serde(rename = "delegatedResourceIdentity")]
4207 DelegatedResourceIdentity,
4208 #[serde(skip_deserializing)]
4209 UnknownValue(String),
4210 }
4211 impl FromStr for IdentityType {
4212 type Err = value::Error;
4213 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
4214 Self::deserialize(s.into_deserializer())
4215 }
4216 }
4217 impl<'de> Deserialize<'de> for IdentityType {
4218 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4219 where
4220 D: Deserializer<'de>,
4221 {
4222 let s = String::deserialize(deserializer)?;
4223 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
4224 Ok(deserialized)
4225 }
4226 }
4227 impl Serialize for IdentityType {
4228 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4229 where
4230 S: Serializer,
4231 {
4232 match self {
4233 Self::SystemAssignedIdentity => serializer.serialize_unit_variant("IdentityType", 0u32, "systemAssignedIdentity"),
4234 Self::UserAssignedIdentity => serializer.serialize_unit_variant("IdentityType", 1u32, "userAssignedIdentity"),
4235 Self::DelegatedResourceIdentity => serializer.serialize_unit_variant("IdentityType", 2u32, "delegatedResourceIdentity"),
4236 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
4237 }
4238 }
4239 }
4240 }
4241}
4242#[doc = "Metadata pertaining to creation and last modification of the resource."]
4243#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4244pub struct SystemData {
4245 #[doc = "The identity that created the resource."]
4246 #[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
4247 pub created_by: Option<String>,
4248 #[doc = "The type of identity that created the resource."]
4249 #[serde(rename = "createdByType", default, skip_serializing_if = "Option::is_none")]
4250 pub created_by_type: Option<system_data::CreatedByType>,
4251 #[doc = "The timestamp of resource creation (UTC)."]
4252 #[serde(rename = "createdAt", default, with = "azure_core::date::rfc3339::option")]
4253 pub created_at: Option<::time::OffsetDateTime>,
4254 #[doc = "The identity that last modified the resource."]
4255 #[serde(rename = "lastModifiedBy", default, skip_serializing_if = "Option::is_none")]
4256 pub last_modified_by: Option<String>,
4257 #[doc = "The type of identity that last modified the resource."]
4258 #[serde(rename = "lastModifiedByType", default, skip_serializing_if = "Option::is_none")]
4259 pub last_modified_by_type: Option<system_data::LastModifiedByType>,
4260 #[doc = "The timestamp of resource last modification (UTC)"]
4261 #[serde(rename = "lastModifiedAt", default, with = "azure_core::date::rfc3339::option")]
4262 pub last_modified_at: Option<::time::OffsetDateTime>,
4263}
4264impl SystemData {
4265 pub fn new() -> Self {
4266 Self::default()
4267 }
4268}
4269pub mod system_data {
4270 use super::*;
4271 #[doc = "The type of identity that created the resource."]
4272 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
4273 #[serde(remote = "CreatedByType")]
4274 pub enum CreatedByType {
4275 User,
4276 Application,
4277 ManagedIdentity,
4278 Key,
4279 #[serde(skip_deserializing)]
4280 UnknownValue(String),
4281 }
4282 impl FromStr for CreatedByType {
4283 type Err = value::Error;
4284 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
4285 Self::deserialize(s.into_deserializer())
4286 }
4287 }
4288 impl<'de> Deserialize<'de> for CreatedByType {
4289 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4290 where
4291 D: Deserializer<'de>,
4292 {
4293 let s = String::deserialize(deserializer)?;
4294 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
4295 Ok(deserialized)
4296 }
4297 }
4298 impl Serialize for CreatedByType {
4299 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4300 where
4301 S: Serializer,
4302 {
4303 match self {
4304 Self::User => serializer.serialize_unit_variant("CreatedByType", 0u32, "User"),
4305 Self::Application => serializer.serialize_unit_variant("CreatedByType", 1u32, "Application"),
4306 Self::ManagedIdentity => serializer.serialize_unit_variant("CreatedByType", 2u32, "ManagedIdentity"),
4307 Self::Key => serializer.serialize_unit_variant("CreatedByType", 3u32, "Key"),
4308 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
4309 }
4310 }
4311 }
4312 #[doc = "The type of identity that last modified the resource."]
4313 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
4314 #[serde(remote = "LastModifiedByType")]
4315 pub enum LastModifiedByType {
4316 User,
4317 Application,
4318 ManagedIdentity,
4319 Key,
4320 #[serde(skip_deserializing)]
4321 UnknownValue(String),
4322 }
4323 impl FromStr for LastModifiedByType {
4324 type Err = value::Error;
4325 fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
4326 Self::deserialize(s.into_deserializer())
4327 }
4328 }
4329 impl<'de> Deserialize<'de> for LastModifiedByType {
4330 fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4331 where
4332 D: Deserializer<'de>,
4333 {
4334 let s = String::deserialize(deserializer)?;
4335 let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
4336 Ok(deserialized)
4337 }
4338 }
4339 impl Serialize for LastModifiedByType {
4340 fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4341 where
4342 S: Serializer,
4343 {
4344 match self {
4345 Self::User => serializer.serialize_unit_variant("LastModifiedByType", 0u32, "User"),
4346 Self::Application => serializer.serialize_unit_variant("LastModifiedByType", 1u32, "Application"),
4347 Self::ManagedIdentity => serializer.serialize_unit_variant("LastModifiedByType", 2u32, "ManagedIdentity"),
4348 Self::Key => serializer.serialize_unit_variant("LastModifiedByType", 3u32, "Key"),
4349 Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
4350 }
4351 }
4352 }
4353}