1#![allow(non_camel_case_types)]
4#![allow(unused_imports)]
5use serde::de::{value, Deserializer, IntoDeserializer};
6use serde::{Deserialize, Serialize, Serializer};
7use std::str::FromStr;
8#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
9pub struct AadOauthTokenRequest {
10 #[serde(default, skip_serializing_if = "Option::is_none")]
11 pub refresh: Option<bool>,
12 #[serde(default, skip_serializing_if = "Option::is_none")]
13 pub resource: Option<String>,
14 #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
15 pub tenant_id: Option<String>,
16 #[serde(default, skip_serializing_if = "Option::is_none")]
17 pub token: Option<String>,
18}
19impl AadOauthTokenRequest {
20 pub fn new() -> Self {
21 Self::default()
22 }
23}
24#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
25pub struct AadOauthTokenResult {
26 #[serde(
27 rename = "accessToken",
28 default,
29 skip_serializing_if = "Option::is_none"
30 )]
31 pub access_token: Option<String>,
32 #[serde(
33 rename = "refreshTokenCache",
34 default,
35 skip_serializing_if = "Option::is_none"
36 )]
37 pub refresh_token_cache: Option<String>,
38}
39impl AadOauthTokenResult {
40 pub fn new() -> Self {
41 Self::default()
42 }
43}
44#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
45pub struct AgentChangeEvent {
46 #[doc = "A task agent."]
47 #[serde(default, skip_serializing_if = "Option::is_none")]
48 pub agent: Option<TaskAgent>,
49 #[serde(rename = "eventType", default, skip_serializing_if = "Option::is_none")]
50 pub event_type: Option<String>,
51 #[serde(default, skip_serializing_if = "Option::is_none")]
52 pub pool: Option<TaskAgentPoolReference>,
53}
54impl AgentChangeEvent {
55 pub fn new() -> Self {
56 Self::default()
57 }
58}
59#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
60pub struct AgentJobRequestMessage {
61 #[serde(flatten)]
62 pub job_request_message: JobRequestMessage,
63 #[serde(
64 rename = "lockedUntil",
65 default,
66 skip_serializing_if = "Option::is_none",
67 with = "crate::date_time::rfc3339::option"
68 )]
69 pub locked_until: Option<time::OffsetDateTime>,
70 #[serde(rename = "lockToken", default, skip_serializing_if = "Option::is_none")]
71 pub lock_token: Option<String>,
72 #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
73 pub request_id: Option<i64>,
74 #[serde(
75 default,
76 deserialize_with = "crate::serde::deserialize_null_as_default",
77 skip_serializing_if = "Vec::is_empty"
78 )]
79 pub tasks: Vec<TaskInstance>,
80}
81impl AgentJobRequestMessage {
82 pub fn new() -> Self {
83 Self::default()
84 }
85}
86#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
87pub struct AgentPoolEvent {
88 #[serde(rename = "eventType", default, skip_serializing_if = "Option::is_none")]
89 pub event_type: Option<String>,
90 #[doc = "An organization-level grouping of agents."]
91 #[serde(default, skip_serializing_if = "Option::is_none")]
92 pub pool: Option<TaskAgentPool>,
93}
94impl AgentPoolEvent {
95 pub fn new() -> Self {
96 Self::default()
97 }
98}
99#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
100pub struct AgentQueueEvent {
101 #[serde(rename = "eventType", default, skip_serializing_if = "Option::is_none")]
102 pub event_type: Option<String>,
103 #[doc = "An agent queue."]
104 #[serde(default, skip_serializing_if = "Option::is_none")]
105 pub queue: Option<TaskAgentQueue>,
106}
107impl AgentQueueEvent {
108 pub fn new() -> Self {
109 Self::default()
110 }
111}
112#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
113pub struct AgentQueuesEvent {
114 #[serde(rename = "eventType", default, skip_serializing_if = "Option::is_none")]
115 pub event_type: Option<String>,
116 #[serde(
117 default,
118 deserialize_with = "crate::serde::deserialize_null_as_default",
119 skip_serializing_if = "Vec::is_empty"
120 )]
121 pub queues: Vec<TaskAgentQueue>,
122}
123impl AgentQueuesEvent {
124 pub fn new() -> Self {
125 Self::default()
126 }
127}
128#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
129pub struct AgentRefreshMessage {
130 #[serde(rename = "agentId", default, skip_serializing_if = "Option::is_none")]
131 pub agent_id: Option<i32>,
132 #[serde(
133 rename = "targetVersion",
134 default,
135 skip_serializing_if = "Option::is_none"
136 )]
137 pub target_version: Option<String>,
138 #[serde(default, skip_serializing_if = "Option::is_none")]
139 pub timeout: Option<String>,
140}
141impl AgentRefreshMessage {
142 pub fn new() -> Self {
143 Self::default()
144 }
145}
146#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
147pub struct AuthenticationSchemeReference {
148 #[serde(default, skip_serializing_if = "Option::is_none")]
149 pub inputs: Option<serde_json::Value>,
150 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
151 pub type_: Option<String>,
152}
153impl AuthenticationSchemeReference {
154 pub fn new() -> Self {
155 Self::default()
156 }
157}
158#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
159pub struct AuthorizationHeader {
160 #[doc = "Gets or sets the name of authorization header."]
161 #[serde(default, skip_serializing_if = "Option::is_none")]
162 pub name: Option<String>,
163 #[doc = "Gets or sets the value of authorization header."]
164 #[serde(default, skip_serializing_if = "Option::is_none")]
165 pub value: Option<String>,
166}
167impl AuthorizationHeader {
168 pub fn new() -> Self {
169 Self::default()
170 }
171}
172#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
173pub struct AzureKeyVaultPermission {
174 #[serde(flatten)]
175 pub azure_resource_permission: AzureResourcePermission,
176 #[serde(default, skip_serializing_if = "Option::is_none")]
177 pub vault: Option<String>,
178}
179impl AzureKeyVaultPermission {
180 pub fn new() -> Self {
181 Self::default()
182 }
183}
184#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
185pub struct AzureKeyVaultVariableGroupProviderData {
186 #[serde(
187 rename = "lastRefreshedOn",
188 default,
189 skip_serializing_if = "Option::is_none",
190 with = "crate::date_time::rfc3339::option"
191 )]
192 pub last_refreshed_on: Option<time::OffsetDateTime>,
193 #[serde(
194 rename = "serviceEndpointId",
195 default,
196 skip_serializing_if = "Option::is_none"
197 )]
198 pub service_endpoint_id: Option<String>,
199 #[serde(default, skip_serializing_if = "Option::is_none")]
200 pub vault: Option<String>,
201}
202impl AzureKeyVaultVariableGroupProviderData {
203 pub fn new() -> Self {
204 Self::default()
205 }
206}
207#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
208pub struct AzureKeyVaultVariableValue {
209 #[serde(flatten)]
210 pub variable_value: VariableValue,
211 #[serde(
212 rename = "contentType",
213 default,
214 skip_serializing_if = "Option::is_none"
215 )]
216 pub content_type: Option<String>,
217 #[serde(default, skip_serializing_if = "Option::is_none")]
218 pub enabled: Option<bool>,
219 #[serde(
220 default,
221 skip_serializing_if = "Option::is_none",
222 with = "crate::date_time::rfc3339::option"
223 )]
224 pub expires: Option<time::OffsetDateTime>,
225}
226impl AzureKeyVaultVariableValue {
227 pub fn new() -> Self {
228 Self::default()
229 }
230}
231#[doc = "Azure Management Group"]
232#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
233pub struct AzureManagementGroup {
234 #[doc = "Display name of azure management group"]
235 #[serde(
236 rename = "displayName",
237 default,
238 skip_serializing_if = "Option::is_none"
239 )]
240 pub display_name: Option<String>,
241 #[doc = "Id of azure management group"]
242 #[serde(default, skip_serializing_if = "Option::is_none")]
243 pub id: Option<String>,
244 #[doc = "Azure management group name"]
245 #[serde(default, skip_serializing_if = "Option::is_none")]
246 pub name: Option<String>,
247 #[doc = "Id of tenant from which azure management group belongs"]
248 #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
249 pub tenant_id: Option<String>,
250}
251impl AzureManagementGroup {
252 pub fn new() -> Self {
253 Self::default()
254 }
255}
256#[doc = "Azure management group query result"]
257#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
258pub struct AzureManagementGroupQueryResult {
259 #[doc = "Error message in case of an exception"]
260 #[serde(
261 rename = "errorMessage",
262 default,
263 skip_serializing_if = "Option::is_none"
264 )]
265 pub error_message: Option<String>,
266 #[doc = "List of azure management groups"]
267 #[serde(
268 default,
269 deserialize_with = "crate::serde::deserialize_null_as_default",
270 skip_serializing_if = "Vec::is_empty"
271 )]
272 pub value: Vec<AzureManagementGroup>,
273}
274impl AzureManagementGroupQueryResult {
275 pub fn new() -> Self {
276 Self::default()
277 }
278}
279#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
280pub struct AzurePermission {
281 #[serde(default, skip_serializing_if = "Option::is_none")]
282 pub provisioned: Option<bool>,
283 #[serde(
284 rename = "resourceProvider",
285 default,
286 skip_serializing_if = "Option::is_none"
287 )]
288 pub resource_provider: Option<String>,
289}
290impl AzurePermission {
291 pub fn new() -> Self {
292 Self::default()
293 }
294}
295#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
296pub struct AzureResourcePermission {
297 #[serde(flatten)]
298 pub azure_permission: AzurePermission,
299 #[serde(
300 rename = "resourceGroup",
301 default,
302 skip_serializing_if = "Option::is_none"
303 )]
304 pub resource_group: Option<String>,
305}
306impl AzureResourcePermission {
307 pub fn new() -> Self {
308 Self::default()
309 }
310}
311#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
312pub struct AzureRoleAssignmentPermission {
313 #[serde(flatten)]
314 pub azure_permission: AzurePermission,
315 #[serde(
316 rename = "roleAssignmentId",
317 default,
318 skip_serializing_if = "Option::is_none"
319 )]
320 pub role_assignment_id: Option<String>,
321}
322impl AzureRoleAssignmentPermission {
323 pub fn new() -> Self {
324 Self::default()
325 }
326}
327#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
328pub struct AzureSpnOperationStatus {
329 #[serde(default, skip_serializing_if = "Option::is_none")]
330 pub state: Option<String>,
331 #[serde(
332 rename = "statusMessage",
333 default,
334 skip_serializing_if = "Option::is_none"
335 )]
336 pub status_message: Option<String>,
337}
338impl AzureSpnOperationStatus {
339 pub fn new() -> Self {
340 Self::default()
341 }
342}
343#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
344pub struct AzureSubscription {
345 #[serde(
346 rename = "displayName",
347 default,
348 skip_serializing_if = "Option::is_none"
349 )]
350 pub display_name: Option<String>,
351 #[serde(
352 rename = "subscriptionId",
353 default,
354 skip_serializing_if = "Option::is_none"
355 )]
356 pub subscription_id: Option<String>,
357 #[serde(
358 rename = "subscriptionTenantId",
359 default,
360 skip_serializing_if = "Option::is_none"
361 )]
362 pub subscription_tenant_id: Option<String>,
363 #[serde(
364 rename = "subscriptionTenantName",
365 default,
366 skip_serializing_if = "Option::is_none"
367 )]
368 pub subscription_tenant_name: Option<String>,
369}
370impl AzureSubscription {
371 pub fn new() -> Self {
372 Self::default()
373 }
374}
375#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
376pub struct AzureSubscriptionQueryResult {
377 #[serde(
378 rename = "errorMessage",
379 default,
380 skip_serializing_if = "Option::is_none"
381 )]
382 pub error_message: Option<String>,
383 #[serde(
384 default,
385 deserialize_with = "crate::serde::deserialize_null_as_default",
386 skip_serializing_if = "Vec::is_empty"
387 )]
388 pub value: Vec<AzureSubscription>,
389}
390impl AzureSubscriptionQueryResult {
391 pub fn new() -> Self {
392 Self::default()
393 }
394}
395#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
396pub struct ClientCertificate {
397 #[doc = "Gets or sets the value of client certificate."]
398 #[serde(default, skip_serializing_if = "Option::is_none")]
399 pub value: Option<String>,
400}
401impl ClientCertificate {
402 pub fn new() -> Self {
403 Self::default()
404 }
405}
406#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
407pub struct CounterVariable {
408 #[serde(default, skip_serializing_if = "Option::is_none")]
409 pub prefix: Option<String>,
410 #[serde(default, skip_serializing_if = "Option::is_none")]
411 pub seed: Option<i32>,
412 #[serde(default, skip_serializing_if = "Option::is_none")]
413 pub value: Option<i32>,
414}
415impl CounterVariable {
416 pub fn new() -> Self {
417 Self::default()
418 }
419}
420#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
421pub struct DataSource {
422 #[serde(
423 rename = "authenticationScheme",
424 default,
425 skip_serializing_if = "Option::is_none"
426 )]
427 pub authentication_scheme: Option<AuthenticationSchemeReference>,
428 #[serde(
429 rename = "endpointUrl",
430 default,
431 skip_serializing_if = "Option::is_none"
432 )]
433 pub endpoint_url: Option<String>,
434 #[serde(
435 default,
436 deserialize_with = "crate::serde::deserialize_null_as_default",
437 skip_serializing_if = "Vec::is_empty"
438 )]
439 pub headers: Vec<AuthorizationHeader>,
440 #[serde(default, skip_serializing_if = "Option::is_none")]
441 pub name: Option<String>,
442 #[serde(
443 rename = "resourceUrl",
444 default,
445 skip_serializing_if = "Option::is_none"
446 )]
447 pub resource_url: Option<String>,
448 #[serde(
449 rename = "resultSelector",
450 default,
451 skip_serializing_if = "Option::is_none"
452 )]
453 pub result_selector: Option<String>,
454}
455impl DataSource {
456 pub fn new() -> Self {
457 Self::default()
458 }
459}
460#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
461pub struct DataSourceBinding {
462 #[serde(flatten)]
463 pub data_source_binding_base: DataSourceBindingBase,
464}
465impl DataSourceBinding {
466 pub fn new() -> Self {
467 Self::default()
468 }
469}
470#[doc = "Represents binding of data source for the service endpoint request."]
471#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
472pub struct DataSourceBindingBase {
473 #[doc = "Pagination format supported by this data source(ContinuationToken/SkipTop)."]
474 #[serde(
475 rename = "callbackContextTemplate",
476 default,
477 skip_serializing_if = "Option::is_none"
478 )]
479 pub callback_context_template: Option<String>,
480 #[doc = "Subsequent calls needed?"]
481 #[serde(
482 rename = "callbackRequiredTemplate",
483 default,
484 skip_serializing_if = "Option::is_none"
485 )]
486 pub callback_required_template: Option<String>,
487 #[doc = "Gets or sets the name of the data source."]
488 #[serde(
489 rename = "dataSourceName",
490 default,
491 skip_serializing_if = "Option::is_none"
492 )]
493 pub data_source_name: Option<String>,
494 #[doc = "Gets or sets the endpoint Id."]
495 #[serde(
496 rename = "endpointId",
497 default,
498 skip_serializing_if = "Option::is_none"
499 )]
500 pub endpoint_id: Option<String>,
501 #[doc = "Gets or sets the url of the service endpoint."]
502 #[serde(
503 rename = "endpointUrl",
504 default,
505 skip_serializing_if = "Option::is_none"
506 )]
507 pub endpoint_url: Option<String>,
508 #[doc = "Gets or sets the authorization headers."]
509 #[serde(
510 default,
511 deserialize_with = "crate::serde::deserialize_null_as_default",
512 skip_serializing_if = "Vec::is_empty"
513 )]
514 pub headers: Vec<AuthorizationHeader>,
515 #[doc = "Defines the initial value of the query params"]
516 #[serde(
517 rename = "initialContextTemplate",
518 default,
519 skip_serializing_if = "Option::is_none"
520 )]
521 pub initial_context_template: Option<String>,
522 #[doc = "Gets or sets the parameters for the data source."]
523 #[serde(default, skip_serializing_if = "Option::is_none")]
524 pub parameters: Option<serde_json::Value>,
525 #[doc = "Gets or sets http request body"]
526 #[serde(
527 rename = "requestContent",
528 default,
529 skip_serializing_if = "Option::is_none"
530 )]
531 pub request_content: Option<String>,
532 #[doc = "Gets or sets http request verb"]
533 #[serde(
534 rename = "requestVerb",
535 default,
536 skip_serializing_if = "Option::is_none"
537 )]
538 pub request_verb: Option<String>,
539 #[doc = "Gets or sets the result selector."]
540 #[serde(
541 rename = "resultSelector",
542 default,
543 skip_serializing_if = "Option::is_none"
544 )]
545 pub result_selector: Option<String>,
546 #[doc = "Gets or sets the result template."]
547 #[serde(
548 rename = "resultTemplate",
549 default,
550 skip_serializing_if = "Option::is_none"
551 )]
552 pub result_template: Option<String>,
553 #[doc = "Gets or sets the target of the data source."]
554 #[serde(default, skip_serializing_if = "Option::is_none")]
555 pub target: Option<String>,
556}
557impl DataSourceBindingBase {
558 pub fn new() -> Self {
559 Self::default()
560 }
561}
562#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
563pub struct DataSourceDetails {
564 #[serde(
565 rename = "dataSourceName",
566 default,
567 skip_serializing_if = "Option::is_none"
568 )]
569 pub data_source_name: Option<String>,
570 #[serde(
571 rename = "dataSourceUrl",
572 default,
573 skip_serializing_if = "Option::is_none"
574 )]
575 pub data_source_url: Option<String>,
576 #[serde(
577 default,
578 deserialize_with = "crate::serde::deserialize_null_as_default",
579 skip_serializing_if = "Vec::is_empty"
580 )]
581 pub headers: Vec<AuthorizationHeader>,
582 #[serde(default, skip_serializing_if = "Option::is_none")]
583 pub parameters: Option<serde_json::Value>,
584 #[serde(
585 rename = "resourceUrl",
586 default,
587 skip_serializing_if = "Option::is_none"
588 )]
589 pub resource_url: Option<String>,
590 #[serde(
591 rename = "resultSelector",
592 default,
593 skip_serializing_if = "Option::is_none"
594 )]
595 pub result_selector: Option<String>,
596}
597impl DataSourceDetails {
598 pub fn new() -> Self {
599 Self::default()
600 }
601}
602#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
603pub struct Demand {
604 #[serde(default, skip_serializing_if = "Option::is_none")]
605 pub name: Option<String>,
606 #[serde(default, skip_serializing_if = "Option::is_none")]
607 pub value: Option<String>,
608}
609impl Demand {
610 pub fn new() -> Self {
611 Self::default()
612 }
613}
614#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
615pub struct DemandEquals {
616 #[serde(flatten)]
617 pub demand: Demand,
618}
619impl DemandEquals {
620 pub fn new() -> Self {
621 Self::default()
622 }
623}
624#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
625pub struct DemandExists {
626 #[serde(flatten)]
627 pub demand: Demand,
628}
629impl DemandExists {
630 pub fn new() -> Self {
631 Self::default()
632 }
633}
634#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
635pub struct DemandMinimumVersion {
636 #[serde(flatten)]
637 pub demand: Demand,
638 #[serde(default, skip_serializing_if = "Option::is_none")]
639 pub source: Option<DemandSource>,
640}
641impl DemandMinimumVersion {
642 pub fn new() -> Self {
643 Self::default()
644 }
645}
646#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
647pub struct DemandSource {
648 #[serde(
649 rename = "sourceName",
650 default,
651 skip_serializing_if = "Option::is_none"
652 )]
653 pub source_name: Option<String>,
654 #[serde(
655 rename = "sourceType",
656 default,
657 skip_serializing_if = "Option::is_none"
658 )]
659 pub source_type: Option<demand_source::SourceType>,
660 #[serde(
661 rename = "sourceVersion",
662 default,
663 skip_serializing_if = "Option::is_none"
664 )]
665 pub source_version: Option<String>,
666}
667impl DemandSource {
668 pub fn new() -> Self {
669 Self::default()
670 }
671}
672pub mod demand_source {
673 use super::*;
674 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
675 pub enum SourceType {
676 #[serde(rename = "task")]
677 Task,
678 #[serde(rename = "feature")]
679 Feature,
680 }
681}
682#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
683pub struct DependencyBinding {
684 #[serde(default, skip_serializing_if = "Option::is_none")]
685 pub key: Option<String>,
686 #[serde(default, skip_serializing_if = "Option::is_none")]
687 pub value: Option<String>,
688}
689impl DependencyBinding {
690 pub fn new() -> Self {
691 Self::default()
692 }
693}
694#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
695pub struct DependencyData {
696 #[serde(default, skip_serializing_if = "Option::is_none")]
697 pub input: Option<String>,
698 #[serde(
699 default,
700 deserialize_with = "crate::serde::deserialize_null_as_default",
701 skip_serializing_if = "Vec::is_empty"
702 )]
703 pub map: Vec<serde_json::Value>,
704}
705impl DependencyData {
706 pub fn new() -> Self {
707 Self::default()
708 }
709}
710#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
711pub struct DependsOn {
712 #[serde(default, skip_serializing_if = "Option::is_none")]
713 pub input: Option<String>,
714 #[serde(
715 default,
716 deserialize_with = "crate::serde::deserialize_null_as_default",
717 skip_serializing_if = "Vec::is_empty"
718 )]
719 pub map: Vec<DependencyBinding>,
720}
721impl DependsOn {
722 pub fn new() -> Self {
723 Self::default()
724 }
725}
726#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
727pub struct DeploymentGatesChangeEvent {
728 #[serde(
729 rename = "gateNames",
730 default,
731 deserialize_with = "crate::serde::deserialize_null_as_default",
732 skip_serializing_if = "Vec::is_empty"
733 )]
734 pub gate_names: Vec<String>,
735}
736impl DeploymentGatesChangeEvent {
737 pub fn new() -> Self {
738 Self::default()
739 }
740}
741#[doc = "Deployment group."]
742#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
743pub struct DeploymentGroup {
744 #[serde(flatten)]
745 pub deployment_group_reference: DeploymentGroupReference,
746 #[doc = "Description of the deployment group."]
747 #[serde(default, skip_serializing_if = "Option::is_none")]
748 pub description: Option<String>,
749 #[doc = "Number of deployment targets in the deployment group."]
750 #[serde(
751 rename = "machineCount",
752 default,
753 skip_serializing_if = "Option::is_none"
754 )]
755 pub machine_count: Option<i32>,
756 #[doc = "List of deployment targets in the deployment group."]
757 #[serde(
758 default,
759 deserialize_with = "crate::serde::deserialize_null_as_default",
760 skip_serializing_if = "Vec::is_empty"
761 )]
762 pub machines: Vec<DeploymentMachine>,
763 #[doc = "List of unique tags across all deployment targets in the deployment group."]
764 #[serde(
765 rename = "machineTags",
766 default,
767 deserialize_with = "crate::serde::deserialize_null_as_default",
768 skip_serializing_if = "Vec::is_empty"
769 )]
770 pub machine_tags: Vec<String>,
771}
772impl DeploymentGroup {
773 pub fn new() -> Self {
774 Self::default()
775 }
776}
777#[doc = "Properties to create Deployment group."]
778#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
779pub struct DeploymentGroupCreateParameter {
780 #[doc = "Description of the deployment group."]
781 #[serde(default, skip_serializing_if = "Option::is_none")]
782 pub description: Option<String>,
783 #[doc = "Name of the deployment group."]
784 #[serde(default, skip_serializing_if = "Option::is_none")]
785 pub name: Option<String>,
786 #[doc = "Identifier of the deployment pool in which deployment agents are registered."]
787 #[serde(rename = "poolId", default, skip_serializing_if = "Option::is_none")]
788 pub pool_id: Option<i32>,
789}
790impl DeploymentGroupCreateParameter {
791 pub fn new() -> Self {
792 Self::default()
793 }
794}
795#[doc = "Properties of Deployment pool to create Deployment group."]
796#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
797pub struct DeploymentGroupCreateParameterPoolProperty {
798 #[doc = "Deployment pool identifier."]
799 #[serde(default, skip_serializing_if = "Option::is_none")]
800 pub id: Option<i32>,
801}
802impl DeploymentGroupCreateParameterPoolProperty {
803 pub fn new() -> Self {
804 Self::default()
805 }
806}
807#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
808pub struct DeploymentGroupList {
809 #[serde(default, skip_serializing_if = "Option::is_none")]
810 pub count: Option<i32>,
811 #[serde(
812 default,
813 deserialize_with = "crate::serde::deserialize_null_as_default",
814 skip_serializing_if = "Vec::is_empty"
815 )]
816 pub value: Vec<DeploymentGroup>,
817}
818impl DeploymentGroupList {
819 pub fn new() -> Self {
820 Self::default()
821 }
822}
823#[doc = "Deployment group metrics."]
824#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
825pub struct DeploymentGroupMetrics {
826 #[doc = "Metrics columns header"]
827 #[serde(
828 rename = "columnsHeader",
829 default,
830 skip_serializing_if = "Option::is_none"
831 )]
832 pub columns_header: Option<MetricsColumnsHeader>,
833 #[doc = "Deployment group reference. This is useful for referring a deployment group in another object."]
834 #[serde(
835 rename = "deploymentGroup",
836 default,
837 skip_serializing_if = "Option::is_none"
838 )]
839 pub deployment_group: Option<DeploymentGroupReference>,
840 #[doc = "Values of properties and the metrics. E.g. 1: total count of deployment targets for which 'TargetState' is 'offline'. E.g. 2: Average time of deployment to the deployment targets for which 'LastJobStatus' is 'passed' and 'TargetState' is 'online'."]
841 #[serde(
842 default,
843 deserialize_with = "crate::serde::deserialize_null_as_default",
844 skip_serializing_if = "Vec::is_empty"
845 )]
846 pub rows: Vec<MetricsRow>,
847}
848impl DeploymentGroupMetrics {
849 pub fn new() -> Self {
850 Self::default()
851 }
852}
853#[doc = "Deployment group reference. This is useful for referring a deployment group in another object."]
854#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
855pub struct DeploymentGroupReference {
856 #[doc = "Deployment group identifier."]
857 #[serde(default, skip_serializing_if = "Option::is_none")]
858 pub id: Option<i32>,
859 #[doc = "Name of the deployment group."]
860 #[serde(default, skip_serializing_if = "Option::is_none")]
861 pub name: Option<String>,
862 #[serde(default, skip_serializing_if = "Option::is_none")]
863 pub pool: Option<TaskAgentPoolReference>,
864 #[serde(default, skip_serializing_if = "Option::is_none")]
865 pub project: Option<ProjectReference>,
866}
867impl DeploymentGroupReference {
868 pub fn new() -> Self {
869 Self::default()
870 }
871}
872#[doc = "Deployment group update parameter."]
873#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
874pub struct DeploymentGroupUpdateParameter {
875 #[doc = "Description of the deployment group."]
876 #[serde(default, skip_serializing_if = "Option::is_none")]
877 pub description: Option<String>,
878 #[doc = "Name of the deployment group."]
879 #[serde(default, skip_serializing_if = "Option::is_none")]
880 pub name: Option<String>,
881}
882impl DeploymentGroupUpdateParameter {
883 pub fn new() -> Self {
884 Self::default()
885 }
886}
887#[doc = "Deployment target."]
888#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
889pub struct DeploymentMachine {
890 #[doc = "A task agent."]
891 #[serde(default, skip_serializing_if = "Option::is_none")]
892 pub agent: Option<TaskAgent>,
893 #[doc = "Deployment target Identifier."]
894 #[serde(default, skip_serializing_if = "Option::is_none")]
895 pub id: Option<i32>,
896 #[doc = "The class represents a property bag as a collection of key-value pairs. Values of all primitive types (any type with a `TypeCode != TypeCode.Object`) except for `DBNull` are accepted. Values of type Byte[], Int32, Double, DateType and String preserve their type, other primitives are retuned as a String. Byte[] expected as base64 encoded string."]
897 #[serde(default, skip_serializing_if = "Option::is_none")]
898 pub properties: Option<PropertiesCollection>,
899 #[doc = "Tags of the deployment target."]
900 #[serde(
901 default,
902 deserialize_with = "crate::serde::deserialize_null_as_default",
903 skip_serializing_if = "Vec::is_empty"
904 )]
905 pub tags: Vec<String>,
906}
907impl DeploymentMachine {
908 pub fn new() -> Self {
909 Self::default()
910 }
911}
912#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
913pub struct DeploymentMachineChangedData {
914 #[serde(flatten)]
915 pub deployment_machine: DeploymentMachine,
916 #[serde(
917 rename = "addedTags",
918 default,
919 deserialize_with = "crate::serde::deserialize_null_as_default",
920 skip_serializing_if = "Vec::is_empty"
921 )]
922 pub added_tags: Vec<String>,
923 #[serde(
924 rename = "deletedTags",
925 default,
926 deserialize_with = "crate::serde::deserialize_null_as_default",
927 skip_serializing_if = "Vec::is_empty"
928 )]
929 pub deleted_tags: Vec<String>,
930}
931impl DeploymentMachineChangedData {
932 pub fn new() -> Self {
933 Self::default()
934 }
935}
936#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
937pub struct DeploymentMachineGroup {
938 #[serde(flatten)]
939 pub deployment_machine_group_reference: DeploymentMachineGroupReference,
940 #[serde(
941 default,
942 deserialize_with = "crate::serde::deserialize_null_as_default",
943 skip_serializing_if = "Vec::is_empty"
944 )]
945 pub machines: Vec<DeploymentMachine>,
946 #[serde(default, skip_serializing_if = "Option::is_none")]
947 pub size: Option<i32>,
948}
949impl DeploymentMachineGroup {
950 pub fn new() -> Self {
951 Self::default()
952 }
953}
954#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
955pub struct DeploymentMachineGroupReference {
956 #[serde(default, skip_serializing_if = "Option::is_none")]
957 pub id: Option<i32>,
958 #[serde(default, skip_serializing_if = "Option::is_none")]
959 pub name: Option<String>,
960 #[serde(default, skip_serializing_if = "Option::is_none")]
961 pub pool: Option<TaskAgentPoolReference>,
962 #[serde(default, skip_serializing_if = "Option::is_none")]
963 pub project: Option<ProjectReference>,
964}
965impl DeploymentMachineGroupReference {
966 pub fn new() -> Self {
967 Self::default()
968 }
969}
970#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
971pub struct DeploymentMachineList {
972 #[serde(default, skip_serializing_if = "Option::is_none")]
973 pub count: Option<i32>,
974 #[serde(
975 default,
976 deserialize_with = "crate::serde::deserialize_null_as_default",
977 skip_serializing_if = "Vec::is_empty"
978 )]
979 pub value: Vec<DeploymentMachine>,
980}
981impl DeploymentMachineList {
982 pub fn new() -> Self {
983 Self::default()
984 }
985}
986#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
987pub struct DeploymentMachinesChangeEvent {
988 #[doc = "Deployment group reference. This is useful for referring a deployment group in another object."]
989 #[serde(
990 rename = "machineGroupReference",
991 default,
992 skip_serializing_if = "Option::is_none"
993 )]
994 pub machine_group_reference: Option<DeploymentGroupReference>,
995 #[serde(
996 default,
997 deserialize_with = "crate::serde::deserialize_null_as_default",
998 skip_serializing_if = "Vec::is_empty"
999 )]
1000 pub machines: Vec<DeploymentMachineChangedData>,
1001}
1002impl DeploymentMachinesChangeEvent {
1003 pub fn new() -> Self {
1004 Self::default()
1005 }
1006}
1007#[doc = "Deployment pool summary."]
1008#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1009pub struct DeploymentPoolSummary {
1010 #[doc = "List of deployment groups referring to the deployment pool."]
1011 #[serde(
1012 rename = "deploymentGroups",
1013 default,
1014 deserialize_with = "crate::serde::deserialize_null_as_default",
1015 skip_serializing_if = "Vec::is_empty"
1016 )]
1017 pub deployment_groups: Vec<DeploymentGroupReference>,
1018 #[doc = "Number of deployment agents that are offline."]
1019 #[serde(
1020 rename = "offlineAgentsCount",
1021 default,
1022 skip_serializing_if = "Option::is_none"
1023 )]
1024 pub offline_agents_count: Option<i32>,
1025 #[doc = "Number of deployment agents that are online."]
1026 #[serde(
1027 rename = "onlineAgentsCount",
1028 default,
1029 skip_serializing_if = "Option::is_none"
1030 )]
1031 pub online_agents_count: Option<i32>,
1032 #[serde(default, skip_serializing_if = "Option::is_none")]
1033 pub pool: Option<TaskAgentPoolReference>,
1034 #[doc = "EnvironmentResourceReference."]
1035 #[serde(default, skip_serializing_if = "Option::is_none")]
1036 pub resource: Option<EnvironmentResourceReference>,
1037}
1038impl DeploymentPoolSummary {
1039 pub fn new() -> Self {
1040 Self::default()
1041 }
1042}
1043#[doc = "Deployment target update parameter."]
1044#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1045pub struct DeploymentTargetUpdateParameter {
1046 #[doc = "Identifier of the deployment target."]
1047 #[serde(default, skip_serializing_if = "Option::is_none")]
1048 pub id: Option<i32>,
1049 #[serde(
1050 default,
1051 deserialize_with = "crate::serde::deserialize_null_as_default",
1052 skip_serializing_if = "Vec::is_empty"
1053 )]
1054 pub tags: Vec<String>,
1055}
1056impl DeploymentTargetUpdateParameter {
1057 pub fn new() -> Self {
1058 Self::default()
1059 }
1060}
1061#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1062pub struct DiagnosticLogMetadata {
1063 #[serde(rename = "agentId", default, skip_serializing_if = "Option::is_none")]
1064 pub agent_id: Option<i32>,
1065 #[serde(rename = "agentName", default, skip_serializing_if = "Option::is_none")]
1066 pub agent_name: Option<String>,
1067 #[serde(rename = "fileName", default, skip_serializing_if = "Option::is_none")]
1068 pub file_name: Option<String>,
1069 #[serde(rename = "phaseName", default, skip_serializing_if = "Option::is_none")]
1070 pub phase_name: Option<String>,
1071 #[serde(
1072 rename = "phaseResult",
1073 default,
1074 skip_serializing_if = "Option::is_none"
1075 )]
1076 pub phase_result: Option<String>,
1077 #[serde(rename = "poolId", default, skip_serializing_if = "Option::is_none")]
1078 pub pool_id: Option<i32>,
1079}
1080impl DiagnosticLogMetadata {
1081 pub fn new() -> Self {
1082 Self::default()
1083 }
1084}
1085#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1086pub struct ElasticAgentPoolResizedEvent {
1087 #[serde(rename = "newSize", default, skip_serializing_if = "Option::is_none")]
1088 pub new_size: Option<i32>,
1089 #[serde(rename = "poolId", default, skip_serializing_if = "Option::is_none")]
1090 pub pool_id: Option<i32>,
1091 #[serde(rename = "poolName", default, skip_serializing_if = "Option::is_none")]
1092 pub pool_name: Option<String>,
1093 #[serde(
1094 rename = "previousSize",
1095 default,
1096 skip_serializing_if = "Option::is_none"
1097 )]
1098 pub previous_size: Option<i32>,
1099 #[serde(
1100 rename = "resourceId",
1101 default,
1102 skip_serializing_if = "Option::is_none"
1103 )]
1104 pub resource_id: Option<String>,
1105}
1106impl ElasticAgentPoolResizedEvent {
1107 pub fn new() -> Self {
1108 Self::default()
1109 }
1110}
1111#[doc = "Data and settings for an elastic node"]
1112#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1113pub struct ElasticNode {
1114 #[doc = "Distributed Task's Agent Id"]
1115 #[serde(rename = "agentId", default, skip_serializing_if = "Option::is_none")]
1116 pub agent_id: Option<i32>,
1117 #[doc = "Summary of the state of the agent"]
1118 #[serde(
1119 rename = "agentState",
1120 default,
1121 skip_serializing_if = "Option::is_none"
1122 )]
1123 pub agent_state: Option<elastic_node::AgentState>,
1124 #[doc = "Compute Id. VMSS's InstanceId"]
1125 #[serde(rename = "computeId", default, skip_serializing_if = "Option::is_none")]
1126 pub compute_id: Option<String>,
1127 #[doc = "State of the compute host"]
1128 #[serde(
1129 rename = "computeState",
1130 default,
1131 skip_serializing_if = "Option::is_none"
1132 )]
1133 pub compute_state: Option<elastic_node::ComputeState>,
1134 #[doc = "Users can force state changes to specific states (ToReimage, ToDelete, Save)"]
1135 #[serde(
1136 rename = "desiredState",
1137 default,
1138 skip_serializing_if = "Option::is_none"
1139 )]
1140 pub desired_state: Option<elastic_node::DesiredState>,
1141 #[doc = "Unique identifier since the agent and/or VM may be null"]
1142 #[serde(default, skip_serializing_if = "Option::is_none")]
1143 pub id: Option<i32>,
1144 #[doc = "Computer name. Used to match a scaleset VM with an agent"]
1145 #[serde(default, skip_serializing_if = "Option::is_none")]
1146 pub name: Option<String>,
1147 #[doc = "Pool Id that this node belongs to"]
1148 #[serde(rename = "poolId", default, skip_serializing_if = "Option::is_none")]
1149 pub pool_id: Option<i32>,
1150 #[doc = "Last job RequestId assigned to this agent"]
1151 #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
1152 pub request_id: Option<i64>,
1153 #[doc = "State of the ElasticNode"]
1154 #[serde(default, skip_serializing_if = "Option::is_none")]
1155 pub state: Option<elastic_node::State>,
1156 #[doc = "Last state change. Only updated by SQL."]
1157 #[serde(
1158 rename = "stateChangedOn",
1159 default,
1160 skip_serializing_if = "Option::is_none",
1161 with = "crate::date_time::rfc3339::option"
1162 )]
1163 pub state_changed_on: Option<time::OffsetDateTime>,
1164}
1165impl ElasticNode {
1166 pub fn new() -> Self {
1167 Self::default()
1168 }
1169}
1170pub mod elastic_node {
1171 use super::*;
1172 #[doc = "Summary of the state of the agent"]
1173 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1174 pub enum AgentState {
1175 #[serde(rename = "none")]
1176 None,
1177 #[serde(rename = "enabled")]
1178 Enabled,
1179 #[serde(rename = "online")]
1180 Online,
1181 #[serde(rename = "assigned")]
1182 Assigned,
1183 }
1184 #[doc = "State of the compute host"]
1185 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1186 pub enum ComputeState {
1187 #[serde(rename = "none")]
1188 None,
1189 #[serde(rename = "healthy")]
1190 Healthy,
1191 #[serde(rename = "creating")]
1192 Creating,
1193 #[serde(rename = "deleting")]
1194 Deleting,
1195 #[serde(rename = "failed")]
1196 Failed,
1197 #[serde(rename = "stopped")]
1198 Stopped,
1199 #[serde(rename = "reimaging")]
1200 Reimaging,
1201 #[serde(rename = "unhealthyVm")]
1202 UnhealthyVm,
1203 #[serde(rename = "unhealthyVmssVm")]
1204 UnhealthyVmssVm,
1205 }
1206 #[doc = "Users can force state changes to specific states (ToReimage, ToDelete, Save)"]
1207 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1208 pub enum DesiredState {
1209 #[serde(rename = "none")]
1210 None,
1211 #[serde(rename = "new")]
1212 New,
1213 #[serde(rename = "creatingCompute")]
1214 CreatingCompute,
1215 #[serde(rename = "startingAgent")]
1216 StartingAgent,
1217 #[serde(rename = "idle")]
1218 Idle,
1219 #[serde(rename = "assigned")]
1220 Assigned,
1221 #[serde(rename = "offline")]
1222 Offline,
1223 #[serde(rename = "pendingReimage")]
1224 PendingReimage,
1225 #[serde(rename = "pendingDelete")]
1226 PendingDelete,
1227 #[serde(rename = "saved")]
1228 Saved,
1229 #[serde(rename = "deletingCompute")]
1230 DeletingCompute,
1231 #[serde(rename = "deleted")]
1232 Deleted,
1233 #[serde(rename = "lost")]
1234 Lost,
1235 #[serde(rename = "reimagingCompute")]
1236 ReimagingCompute,
1237 #[serde(rename = "restartingAgent")]
1238 RestartingAgent,
1239 #[serde(rename = "failedToStartPendingDelete")]
1240 FailedToStartPendingDelete,
1241 #[serde(rename = "failedToRestartPendingDelete")]
1242 FailedToRestartPendingDelete,
1243 #[serde(rename = "failedVMPendingDelete")]
1244 FailedVmPendingDelete,
1245 #[serde(rename = "assignedPendingDelete")]
1246 AssignedPendingDelete,
1247 #[serde(rename = "retryDelete")]
1248 RetryDelete,
1249 #[serde(rename = "unhealthyVm")]
1250 UnhealthyVm,
1251 #[serde(rename = "unhealthyVmPendingDelete")]
1252 UnhealthyVmPendingDelete,
1253 }
1254 #[doc = "State of the ElasticNode"]
1255 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1256 pub enum State {
1257 #[serde(rename = "none")]
1258 None,
1259 #[serde(rename = "new")]
1260 New,
1261 #[serde(rename = "creatingCompute")]
1262 CreatingCompute,
1263 #[serde(rename = "startingAgent")]
1264 StartingAgent,
1265 #[serde(rename = "idle")]
1266 Idle,
1267 #[serde(rename = "assigned")]
1268 Assigned,
1269 #[serde(rename = "offline")]
1270 Offline,
1271 #[serde(rename = "pendingReimage")]
1272 PendingReimage,
1273 #[serde(rename = "pendingDelete")]
1274 PendingDelete,
1275 #[serde(rename = "saved")]
1276 Saved,
1277 #[serde(rename = "deletingCompute")]
1278 DeletingCompute,
1279 #[serde(rename = "deleted")]
1280 Deleted,
1281 #[serde(rename = "lost")]
1282 Lost,
1283 #[serde(rename = "reimagingCompute")]
1284 ReimagingCompute,
1285 #[serde(rename = "restartingAgent")]
1286 RestartingAgent,
1287 #[serde(rename = "failedToStartPendingDelete")]
1288 FailedToStartPendingDelete,
1289 #[serde(rename = "failedToRestartPendingDelete")]
1290 FailedToRestartPendingDelete,
1291 #[serde(rename = "failedVMPendingDelete")]
1292 FailedVmPendingDelete,
1293 #[serde(rename = "assignedPendingDelete")]
1294 AssignedPendingDelete,
1295 #[serde(rename = "retryDelete")]
1296 RetryDelete,
1297 #[serde(rename = "unhealthyVm")]
1298 UnhealthyVm,
1299 #[serde(rename = "unhealthyVmPendingDelete")]
1300 UnhealthyVmPendingDelete,
1301 }
1302}
1303#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1304pub struct ElasticNodeList {
1305 #[serde(default, skip_serializing_if = "Option::is_none")]
1306 pub count: Option<i32>,
1307 #[serde(
1308 default,
1309 deserialize_with = "crate::serde::deserialize_null_as_default",
1310 skip_serializing_if = "Vec::is_empty"
1311 )]
1312 pub value: Vec<ElasticNode>,
1313}
1314impl ElasticNodeList {
1315 pub fn new() -> Self {
1316 Self::default()
1317 }
1318}
1319#[doc = "Class used for updating an elastic node where only certain members are populated"]
1320#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1321pub struct ElasticNodeSettings {
1322 #[doc = "State of the ElasticNode"]
1323 #[serde(default, skip_serializing_if = "Option::is_none")]
1324 pub state: Option<elastic_node_settings::State>,
1325}
1326impl ElasticNodeSettings {
1327 pub fn new() -> Self {
1328 Self::default()
1329 }
1330}
1331pub mod elastic_node_settings {
1332 use super::*;
1333 #[doc = "State of the ElasticNode"]
1334 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1335 pub enum State {
1336 #[serde(rename = "none")]
1337 None,
1338 #[serde(rename = "new")]
1339 New,
1340 #[serde(rename = "creatingCompute")]
1341 CreatingCompute,
1342 #[serde(rename = "startingAgent")]
1343 StartingAgent,
1344 #[serde(rename = "idle")]
1345 Idle,
1346 #[serde(rename = "assigned")]
1347 Assigned,
1348 #[serde(rename = "offline")]
1349 Offline,
1350 #[serde(rename = "pendingReimage")]
1351 PendingReimage,
1352 #[serde(rename = "pendingDelete")]
1353 PendingDelete,
1354 #[serde(rename = "saved")]
1355 Saved,
1356 #[serde(rename = "deletingCompute")]
1357 DeletingCompute,
1358 #[serde(rename = "deleted")]
1359 Deleted,
1360 #[serde(rename = "lost")]
1361 Lost,
1362 #[serde(rename = "reimagingCompute")]
1363 ReimagingCompute,
1364 #[serde(rename = "restartingAgent")]
1365 RestartingAgent,
1366 #[serde(rename = "failedToStartPendingDelete")]
1367 FailedToStartPendingDelete,
1368 #[serde(rename = "failedToRestartPendingDelete")]
1369 FailedToRestartPendingDelete,
1370 #[serde(rename = "failedVMPendingDelete")]
1371 FailedVmPendingDelete,
1372 #[serde(rename = "assignedPendingDelete")]
1373 AssignedPendingDelete,
1374 #[serde(rename = "retryDelete")]
1375 RetryDelete,
1376 #[serde(rename = "unhealthyVm")]
1377 UnhealthyVm,
1378 #[serde(rename = "unhealthyVmPendingDelete")]
1379 UnhealthyVmPendingDelete,
1380 }
1381}
1382#[doc = "Data and settings for an elastic pool"]
1383#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1384pub struct ElasticPool {
1385 #[doc = "Set whether agents should be configured to run with interactive UI"]
1386 #[serde(
1387 rename = "agentInteractiveUI",
1388 default,
1389 skip_serializing_if = "Option::is_none"
1390 )]
1391 pub agent_interactive_ui: Option<bool>,
1392 #[doc = "Azure string representing to location of the resource"]
1393 #[serde(rename = "azureId", default, skip_serializing_if = "Option::is_none")]
1394 pub azure_id: Option<String>,
1395 #[doc = "Number of agents to have ready waiting for jobs"]
1396 #[serde(
1397 rename = "desiredIdle",
1398 default,
1399 skip_serializing_if = "Option::is_none"
1400 )]
1401 pub desired_idle: Option<i32>,
1402 #[doc = "The desired size of the pool"]
1403 #[serde(
1404 rename = "desiredSize",
1405 default,
1406 skip_serializing_if = "Option::is_none"
1407 )]
1408 pub desired_size: Option<i32>,
1409 #[doc = "Maximum number of nodes that will exist in the elastic pool"]
1410 #[serde(
1411 rename = "maxCapacity",
1412 default,
1413 skip_serializing_if = "Option::is_none"
1414 )]
1415 pub max_capacity: Option<i32>,
1416 #[doc = "Keep nodes in the pool on failure for investigation"]
1417 #[serde(
1418 rename = "maxSavedNodeCount",
1419 default,
1420 skip_serializing_if = "Option::is_none"
1421 )]
1422 pub max_saved_node_count: Option<i32>,
1423 #[doc = "Timestamp the pool was first detected to be offline"]
1424 #[serde(
1425 rename = "offlineSince",
1426 default,
1427 skip_serializing_if = "Option::is_none",
1428 with = "crate::date_time::rfc3339::option"
1429 )]
1430 pub offline_since: Option<time::OffsetDateTime>,
1431 #[doc = "Operating system type of the nodes in the pool"]
1432 #[serde(
1433 rename = "orchestrationType",
1434 default,
1435 skip_serializing_if = "Option::is_none"
1436 )]
1437 pub orchestration_type: Option<elastic_pool::OrchestrationType>,
1438 #[doc = "Operating system type of the nodes in the pool"]
1439 #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
1440 pub os_type: Option<elastic_pool::OsType>,
1441 #[doc = "Id of the associated TaskAgentPool"]
1442 #[serde(rename = "poolId", default, skip_serializing_if = "Option::is_none")]
1443 pub pool_id: Option<i32>,
1444 #[doc = "Discard node after each job completes"]
1445 #[serde(
1446 rename = "recycleAfterEachUse",
1447 default,
1448 skip_serializing_if = "Option::is_none"
1449 )]
1450 pub recycle_after_each_use: Option<bool>,
1451 #[doc = "Id of the Service Endpoint used to connect to Azure"]
1452 #[serde(
1453 rename = "serviceEndpointId",
1454 default,
1455 skip_serializing_if = "Option::is_none"
1456 )]
1457 pub service_endpoint_id: Option<String>,
1458 #[doc = "Scope the Service Endpoint belongs to"]
1459 #[serde(
1460 rename = "serviceEndpointScope",
1461 default,
1462 skip_serializing_if = "Option::is_none"
1463 )]
1464 pub service_endpoint_scope: Option<String>,
1465 #[doc = "The number of sizing attempts executed while trying to achieve a desired size"]
1466 #[serde(
1467 rename = "sizingAttempts",
1468 default,
1469 skip_serializing_if = "Option::is_none"
1470 )]
1471 pub sizing_attempts: Option<i32>,
1472 #[doc = "State of the pool"]
1473 #[serde(default, skip_serializing_if = "Option::is_none")]
1474 pub state: Option<elastic_pool::State>,
1475 #[doc = "The minimum time in minutes to keep idle agents alive"]
1476 #[serde(
1477 rename = "timeToLiveMinutes",
1478 default,
1479 skip_serializing_if = "Option::is_none"
1480 )]
1481 pub time_to_live_minutes: Option<i32>,
1482}
1483impl ElasticPool {
1484 pub fn new() -> Self {
1485 Self::default()
1486 }
1487}
1488pub mod elastic_pool {
1489 use super::*;
1490 #[doc = "Operating system type of the nodes in the pool"]
1491 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1492 pub enum OrchestrationType {
1493 #[serde(rename = "uniform")]
1494 Uniform,
1495 #[serde(rename = "flexible")]
1496 Flexible,
1497 }
1498 #[doc = "Operating system type of the nodes in the pool"]
1499 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1500 pub enum OsType {
1501 #[serde(rename = "windows")]
1502 Windows,
1503 #[serde(rename = "linux")]
1504 Linux,
1505 }
1506 #[doc = "State of the pool"]
1507 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1508 pub enum State {
1509 #[serde(rename = "online")]
1510 Online,
1511 #[serde(rename = "offline")]
1512 Offline,
1513 #[serde(rename = "unhealthy")]
1514 Unhealthy,
1515 #[serde(rename = "new")]
1516 New,
1517 }
1518}
1519#[doc = "Returned result from creating a new elastic pool"]
1520#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1521pub struct ElasticPoolCreationResult {
1522 #[doc = "An organization-level grouping of agents."]
1523 #[serde(rename = "agentPool", default, skip_serializing_if = "Option::is_none")]
1524 pub agent_pool: Option<TaskAgentPool>,
1525 #[doc = "An agent queue."]
1526 #[serde(
1527 rename = "agentQueue",
1528 default,
1529 skip_serializing_if = "Option::is_none"
1530 )]
1531 pub agent_queue: Option<TaskAgentQueue>,
1532 #[doc = "Data and settings for an elastic pool"]
1533 #[serde(
1534 rename = "elasticPool",
1535 default,
1536 skip_serializing_if = "Option::is_none"
1537 )]
1538 pub elastic_pool: Option<ElasticPool>,
1539}
1540impl ElasticPoolCreationResult {
1541 pub fn new() -> Self {
1542 Self::default()
1543 }
1544}
1545#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1546pub struct ElasticPoolList {
1547 #[serde(default, skip_serializing_if = "Option::is_none")]
1548 pub count: Option<i32>,
1549 #[serde(
1550 default,
1551 deserialize_with = "crate::serde::deserialize_null_as_default",
1552 skip_serializing_if = "Vec::is_empty"
1553 )]
1554 pub value: Vec<ElasticPool>,
1555}
1556impl ElasticPoolList {
1557 pub fn new() -> Self {
1558 Self::default()
1559 }
1560}
1561#[doc = "Log data for an Elastic Pool"]
1562#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1563pub struct ElasticPoolLog {
1564 #[doc = "Log Id"]
1565 #[serde(default, skip_serializing_if = "Option::is_none")]
1566 pub id: Option<i64>,
1567 #[doc = "E.g. error, warning, info"]
1568 #[serde(default, skip_serializing_if = "Option::is_none")]
1569 pub level: Option<elastic_pool_log::Level>,
1570 #[doc = "Log contents"]
1571 #[serde(default, skip_serializing_if = "Option::is_none")]
1572 pub message: Option<String>,
1573 #[doc = "Operation that triggered the message being logged"]
1574 #[serde(default, skip_serializing_if = "Option::is_none")]
1575 pub operation: Option<elastic_pool_log::Operation>,
1576 #[doc = "Id of the associated TaskAgentPool"]
1577 #[serde(rename = "poolId", default, skip_serializing_if = "Option::is_none")]
1578 pub pool_id: Option<i32>,
1579 #[doc = "Datetime that the log occurred"]
1580 #[serde(
1581 default,
1582 skip_serializing_if = "Option::is_none",
1583 with = "crate::date_time::rfc3339::option"
1584 )]
1585 pub timestamp: Option<time::OffsetDateTime>,
1586}
1587impl ElasticPoolLog {
1588 pub fn new() -> Self {
1589 Self::default()
1590 }
1591}
1592pub mod elastic_pool_log {
1593 use super::*;
1594 #[doc = "E.g. error, warning, info"]
1595 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1596 pub enum Level {
1597 #[serde(rename = "error")]
1598 Error,
1599 #[serde(rename = "warning")]
1600 Warning,
1601 #[serde(rename = "info")]
1602 Info,
1603 }
1604 #[doc = "Operation that triggered the message being logged"]
1605 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1606 pub enum Operation {
1607 #[serde(rename = "configurationJob")]
1608 ConfigurationJob,
1609 #[serde(rename = "sizingJob")]
1610 SizingJob,
1611 #[serde(rename = "increaseCapacity")]
1612 IncreaseCapacity,
1613 #[serde(rename = "reimage")]
1614 Reimage,
1615 #[serde(rename = "deleteVMs")]
1616 DeleteVMs,
1617 }
1618}
1619#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1620pub struct ElasticPoolLogList {
1621 #[serde(default, skip_serializing_if = "Option::is_none")]
1622 pub count: Option<i32>,
1623 #[serde(
1624 default,
1625 deserialize_with = "crate::serde::deserialize_null_as_default",
1626 skip_serializing_if = "Vec::is_empty"
1627 )]
1628 pub value: Vec<ElasticPoolLog>,
1629}
1630impl ElasticPoolLogList {
1631 pub fn new() -> Self {
1632 Self::default()
1633 }
1634}
1635#[doc = "Class used for updating an elastic pool where only certain members are populated"]
1636#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1637pub struct ElasticPoolSettings {
1638 #[doc = "Set whether agents should be configured to run with interactive UI"]
1639 #[serde(
1640 rename = "agentInteractiveUI",
1641 default,
1642 skip_serializing_if = "Option::is_none"
1643 )]
1644 pub agent_interactive_ui: Option<bool>,
1645 #[doc = "Azure string representing to location of the resource"]
1646 #[serde(rename = "azureId", default, skip_serializing_if = "Option::is_none")]
1647 pub azure_id: Option<String>,
1648 #[doc = "Number of machines to have ready waiting for jobs"]
1649 #[serde(
1650 rename = "desiredIdle",
1651 default,
1652 skip_serializing_if = "Option::is_none"
1653 )]
1654 pub desired_idle: Option<i32>,
1655 #[doc = "Maximum number of machines that will exist in the elastic pool"]
1656 #[serde(
1657 rename = "maxCapacity",
1658 default,
1659 skip_serializing_if = "Option::is_none"
1660 )]
1661 pub max_capacity: Option<i32>,
1662 #[doc = "Keep machines in the pool on failure for investigation"]
1663 #[serde(
1664 rename = "maxSavedNodeCount",
1665 default,
1666 skip_serializing_if = "Option::is_none"
1667 )]
1668 pub max_saved_node_count: Option<i32>,
1669 #[doc = "Operating system type of the machines in the pool"]
1670 #[serde(
1671 rename = "orchestrationType",
1672 default,
1673 skip_serializing_if = "Option::is_none"
1674 )]
1675 pub orchestration_type: Option<elastic_pool_settings::OrchestrationType>,
1676 #[doc = "Operating system type of the machines in the pool"]
1677 #[serde(rename = "osType", default, skip_serializing_if = "Option::is_none")]
1678 pub os_type: Option<elastic_pool_settings::OsType>,
1679 #[doc = "Discard machines after each job completes"]
1680 #[serde(
1681 rename = "recycleAfterEachUse",
1682 default,
1683 skip_serializing_if = "Option::is_none"
1684 )]
1685 pub recycle_after_each_use: Option<bool>,
1686 #[doc = "Id of the Service Endpoint used to connect to Azure"]
1687 #[serde(
1688 rename = "serviceEndpointId",
1689 default,
1690 skip_serializing_if = "Option::is_none"
1691 )]
1692 pub service_endpoint_id: Option<String>,
1693 #[doc = "Scope the Service Endpoint belongs to"]
1694 #[serde(
1695 rename = "serviceEndpointScope",
1696 default,
1697 skip_serializing_if = "Option::is_none"
1698 )]
1699 pub service_endpoint_scope: Option<String>,
1700 #[doc = "The minimum time in minutes to keep idle agents alive"]
1701 #[serde(
1702 rename = "timeToLiveMinutes",
1703 default,
1704 skip_serializing_if = "Option::is_none"
1705 )]
1706 pub time_to_live_minutes: Option<i32>,
1707}
1708impl ElasticPoolSettings {
1709 pub fn new() -> Self {
1710 Self::default()
1711 }
1712}
1713pub mod elastic_pool_settings {
1714 use super::*;
1715 #[doc = "Operating system type of the machines in the pool"]
1716 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1717 pub enum OrchestrationType {
1718 #[serde(rename = "uniform")]
1719 Uniform,
1720 #[serde(rename = "flexible")]
1721 Flexible,
1722 }
1723 #[doc = "Operating system type of the machines in the pool"]
1724 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1725 pub enum OsType {
1726 #[serde(rename = "windows")]
1727 Windows,
1728 #[serde(rename = "linux")]
1729 Linux,
1730 }
1731}
1732#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1733pub struct EndpointAuthorization {
1734 #[doc = "Gets or sets the parameters for the selected authorization scheme."]
1735 #[serde(default, skip_serializing_if = "Option::is_none")]
1736 pub parameters: Option<serde_json::Value>,
1737 #[doc = "Gets or sets the scheme used for service endpoint authentication."]
1738 #[serde(default, skip_serializing_if = "Option::is_none")]
1739 pub scheme: Option<String>,
1740}
1741impl EndpointAuthorization {
1742 pub fn new() -> Self {
1743 Self::default()
1744 }
1745}
1746#[doc = "Represents url of the service endpoint."]
1747#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1748pub struct EndpointUrl {
1749 #[serde(rename = "dependsOn", default, skip_serializing_if = "Option::is_none")]
1750 pub depends_on: Option<DependsOn>,
1751 #[doc = "Gets or sets the display name of service endpoint url."]
1752 #[serde(
1753 rename = "displayName",
1754 default,
1755 skip_serializing_if = "Option::is_none"
1756 )]
1757 pub display_name: Option<String>,
1758 #[doc = "Gets or sets the help text of service endpoint url."]
1759 #[serde(rename = "helpText", default, skip_serializing_if = "Option::is_none")]
1760 pub help_text: Option<String>,
1761 #[doc = "Gets or sets the visibility of service endpoint url."]
1762 #[serde(rename = "isVisible", default, skip_serializing_if = "Option::is_none")]
1763 pub is_visible: Option<String>,
1764 #[doc = "Gets or sets the value of service endpoint url."]
1765 #[serde(default, skip_serializing_if = "Option::is_none")]
1766 pub value: Option<String>,
1767}
1768impl EndpointUrl {
1769 pub fn new() -> Self {
1770 Self::default()
1771 }
1772}
1773#[doc = "Properties to create Environment."]
1774#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1775pub struct EnvironmentCreateParameter {
1776 #[doc = "Description of the environment."]
1777 #[serde(default, skip_serializing_if = "Option::is_none")]
1778 pub description: Option<String>,
1779 #[doc = "Name of the environment."]
1780 #[serde(default, skip_serializing_if = "Option::is_none")]
1781 pub name: Option<String>,
1782}
1783impl EnvironmentCreateParameter {
1784 pub fn new() -> Self {
1785 Self::default()
1786 }
1787}
1788#[doc = "EnvironmentDeploymentExecutionRecord."]
1789#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1790pub struct EnvironmentDeploymentExecutionRecord {
1791 #[serde(default, skip_serializing_if = "Option::is_none")]
1792 pub definition: Option<TaskOrchestrationOwner>,
1793 #[doc = "Id of the Environment"]
1794 #[serde(
1795 rename = "environmentId",
1796 default,
1797 skip_serializing_if = "Option::is_none"
1798 )]
1799 pub environment_id: Option<i32>,
1800 #[doc = "Finish time of the environment deployment execution"]
1801 #[serde(
1802 rename = "finishTime",
1803 default,
1804 skip_serializing_if = "Option::is_none",
1805 with = "crate::date_time::rfc3339::option"
1806 )]
1807 pub finish_time: Option<time::OffsetDateTime>,
1808 #[doc = "Id of the Environment deployment execution history record"]
1809 #[serde(default, skip_serializing_if = "Option::is_none")]
1810 pub id: Option<i64>,
1811 #[doc = "Job Attempt"]
1812 #[serde(
1813 rename = "jobAttempt",
1814 default,
1815 skip_serializing_if = "Option::is_none"
1816 )]
1817 pub job_attempt: Option<i32>,
1818 #[doc = "Job name"]
1819 #[serde(rename = "jobName", default, skip_serializing_if = "Option::is_none")]
1820 pub job_name: Option<String>,
1821 #[serde(default, skip_serializing_if = "Option::is_none")]
1822 pub owner: Option<TaskOrchestrationOwner>,
1823 #[doc = "Plan Id"]
1824 #[serde(rename = "planId", default, skip_serializing_if = "Option::is_none")]
1825 pub plan_id: Option<String>,
1826 #[doc = "Plan type of the environment deployment execution record"]
1827 #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
1828 pub plan_type: Option<String>,
1829 #[doc = "Queue time of the environment deployment execution"]
1830 #[serde(
1831 rename = "queueTime",
1832 default,
1833 skip_serializing_if = "Option::is_none",
1834 with = "crate::date_time::rfc3339::option"
1835 )]
1836 pub queue_time: Option<time::OffsetDateTime>,
1837 #[doc = "Request identifier of the Environment deployment execution history record"]
1838 #[serde(
1839 rename = "requestIdentifier",
1840 default,
1841 skip_serializing_if = "Option::is_none"
1842 )]
1843 pub request_identifier: Option<String>,
1844 #[doc = "Resource Id"]
1845 #[serde(
1846 rename = "resourceId",
1847 default,
1848 skip_serializing_if = "Option::is_none"
1849 )]
1850 pub resource_id: Option<i32>,
1851 #[doc = "Result of the environment deployment execution"]
1852 #[serde(default, skip_serializing_if = "Option::is_none")]
1853 pub result: Option<environment_deployment_execution_record::Result>,
1854 #[doc = "Project Id"]
1855 #[serde(rename = "scopeId", default, skip_serializing_if = "Option::is_none")]
1856 pub scope_id: Option<String>,
1857 #[doc = "Service owner Id"]
1858 #[serde(
1859 rename = "serviceOwner",
1860 default,
1861 skip_serializing_if = "Option::is_none"
1862 )]
1863 pub service_owner: Option<String>,
1864 #[doc = "Stage Attempt"]
1865 #[serde(
1866 rename = "stageAttempt",
1867 default,
1868 skip_serializing_if = "Option::is_none"
1869 )]
1870 pub stage_attempt: Option<i32>,
1871 #[doc = "Stage name"]
1872 #[serde(rename = "stageName", default, skip_serializing_if = "Option::is_none")]
1873 pub stage_name: Option<String>,
1874 #[doc = "Start time of the environment deployment execution"]
1875 #[serde(
1876 rename = "startTime",
1877 default,
1878 skip_serializing_if = "Option::is_none",
1879 with = "crate::date_time::rfc3339::option"
1880 )]
1881 pub start_time: Option<time::OffsetDateTime>,
1882}
1883impl EnvironmentDeploymentExecutionRecord {
1884 pub fn new() -> Self {
1885 Self::default()
1886 }
1887}
1888pub mod environment_deployment_execution_record {
1889 use super::*;
1890 #[doc = "Result of the environment deployment execution"]
1891 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
1892 pub enum Result {
1893 #[serde(rename = "succeeded")]
1894 Succeeded,
1895 #[serde(rename = "succeededWithIssues")]
1896 SucceededWithIssues,
1897 #[serde(rename = "failed")]
1898 Failed,
1899 #[serde(rename = "canceled")]
1900 Canceled,
1901 #[serde(rename = "skipped")]
1902 Skipped,
1903 #[serde(rename = "abandoned")]
1904 Abandoned,
1905 }
1906}
1907#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1908pub struct EnvironmentDeploymentExecutionRecordList {
1909 #[serde(default, skip_serializing_if = "Option::is_none")]
1910 pub count: Option<i32>,
1911 #[serde(
1912 default,
1913 deserialize_with = "crate::serde::deserialize_null_as_default",
1914 skip_serializing_if = "Vec::is_empty"
1915 )]
1916 pub value: Vec<EnvironmentDeploymentExecutionRecord>,
1917}
1918impl EnvironmentDeploymentExecutionRecordList {
1919 pub fn new() -> Self {
1920 Self::default()
1921 }
1922}
1923#[doc = "Environment."]
1924#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1925pub struct EnvironmentInstance {
1926 #[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
1927 pub created_by: Option<IdentityRef>,
1928 #[doc = "Creation time of the Environment"]
1929 #[serde(
1930 rename = "createdOn",
1931 default,
1932 skip_serializing_if = "Option::is_none",
1933 with = "crate::date_time::rfc3339::option"
1934 )]
1935 pub created_on: Option<time::OffsetDateTime>,
1936 #[doc = "Description of the Environment."]
1937 #[serde(default, skip_serializing_if = "Option::is_none")]
1938 pub description: Option<String>,
1939 #[doc = "Id of the Environment"]
1940 #[serde(default, skip_serializing_if = "Option::is_none")]
1941 pub id: Option<i32>,
1942 #[serde(
1943 rename = "lastModifiedBy",
1944 default,
1945 skip_serializing_if = "Option::is_none"
1946 )]
1947 pub last_modified_by: Option<IdentityRef>,
1948 #[doc = "Last modified time of the Environment"]
1949 #[serde(
1950 rename = "lastModifiedOn",
1951 default,
1952 skip_serializing_if = "Option::is_none",
1953 with = "crate::date_time::rfc3339::option"
1954 )]
1955 pub last_modified_on: Option<time::OffsetDateTime>,
1956 #[doc = "Name of the Environment."]
1957 #[serde(default, skip_serializing_if = "Option::is_none")]
1958 pub name: Option<String>,
1959 #[serde(default, skip_serializing_if = "Option::is_none")]
1960 pub project: Option<ProjectReference>,
1961 #[serde(
1962 default,
1963 deserialize_with = "crate::serde::deserialize_null_as_default",
1964 skip_serializing_if = "Vec::is_empty"
1965 )]
1966 pub resources: Vec<EnvironmentResourceReference>,
1967}
1968impl EnvironmentInstance {
1969 pub fn new() -> Self {
1970 Self::default()
1971 }
1972}
1973#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1974pub struct EnvironmentInstanceList {
1975 #[serde(default, skip_serializing_if = "Option::is_none")]
1976 pub count: Option<i32>,
1977 #[serde(
1978 default,
1979 deserialize_with = "crate::serde::deserialize_null_as_default",
1980 skip_serializing_if = "Vec::is_empty"
1981 )]
1982 pub value: Vec<EnvironmentInstance>,
1983}
1984impl EnvironmentInstanceList {
1985 pub fn new() -> Self {
1986 Self::default()
1987 }
1988}
1989#[doc = "EnvironmentLinkedResourceReference."]
1990#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
1991pub struct EnvironmentLinkedResourceReference {
1992 #[doc = "Id of the resource."]
1993 #[serde(default, skip_serializing_if = "Option::is_none")]
1994 pub id: Option<String>,
1995 #[doc = "Type of resource."]
1996 #[serde(rename = "typeName", default, skip_serializing_if = "Option::is_none")]
1997 pub type_name: Option<String>,
1998}
1999impl EnvironmentLinkedResourceReference {
2000 pub fn new() -> Self {
2001 Self::default()
2002 }
2003}
2004#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2005pub struct EnvironmentReference {
2006 #[serde(default, skip_serializing_if = "Option::is_none")]
2007 pub id: Option<i32>,
2008 #[serde(default, skip_serializing_if = "Option::is_none")]
2009 pub name: Option<String>,
2010}
2011impl EnvironmentReference {
2012 pub fn new() -> Self {
2013 Self::default()
2014 }
2015}
2016#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2017pub struct EnvironmentResource {
2018 #[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
2019 pub created_by: Option<IdentityRef>,
2020 #[serde(
2021 rename = "createdOn",
2022 default,
2023 skip_serializing_if = "Option::is_none",
2024 with = "crate::date_time::rfc3339::option"
2025 )]
2026 pub created_on: Option<time::OffsetDateTime>,
2027 #[serde(
2028 rename = "environmentReference",
2029 default,
2030 skip_serializing_if = "Option::is_none"
2031 )]
2032 pub environment_reference: Option<EnvironmentReference>,
2033 #[serde(default, skip_serializing_if = "Option::is_none")]
2034 pub id: Option<i32>,
2035 #[serde(
2036 rename = "lastModifiedBy",
2037 default,
2038 skip_serializing_if = "Option::is_none"
2039 )]
2040 pub last_modified_by: Option<IdentityRef>,
2041 #[serde(
2042 rename = "lastModifiedOn",
2043 default,
2044 skip_serializing_if = "Option::is_none",
2045 with = "crate::date_time::rfc3339::option"
2046 )]
2047 pub last_modified_on: Option<time::OffsetDateTime>,
2048 #[serde(default, skip_serializing_if = "Option::is_none")]
2049 pub name: Option<String>,
2050 #[doc = "Tags of the Environment Resource."]
2051 #[serde(
2052 default,
2053 deserialize_with = "crate::serde::deserialize_null_as_default",
2054 skip_serializing_if = "Vec::is_empty"
2055 )]
2056 pub tags: Vec<String>,
2057 #[doc = "Environment resource type"]
2058 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
2059 pub type_: Option<environment_resource::Type>,
2060}
2061impl EnvironmentResource {
2062 pub fn new() -> Self {
2063 Self::default()
2064 }
2065}
2066pub mod environment_resource {
2067 use super::*;
2068 #[doc = "Environment resource type"]
2069 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2070 pub enum Type {
2071 #[serde(rename = "undefined")]
2072 Undefined,
2073 #[serde(rename = "generic")]
2074 Generic,
2075 #[serde(rename = "virtualMachine")]
2076 VirtualMachine,
2077 #[serde(rename = "kubernetes")]
2078 Kubernetes,
2079 }
2080}
2081#[doc = "EnvironmentResourceDeploymentExecutionRecord."]
2082#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2083pub struct EnvironmentResourceDeploymentExecutionRecord {
2084 #[doc = "Id of the Environment"]
2085 #[serde(
2086 rename = "environmentId",
2087 default,
2088 skip_serializing_if = "Option::is_none"
2089 )]
2090 pub environment_id: Option<i32>,
2091 #[doc = "Finish time of the environment resource deployment execution"]
2092 #[serde(
2093 rename = "finishTime",
2094 default,
2095 skip_serializing_if = "Option::is_none",
2096 with = "crate::date_time::rfc3339::option"
2097 )]
2098 pub finish_time: Option<time::OffsetDateTime>,
2099 #[doc = "Id of the Environment deployment execution history record"]
2100 #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
2101 pub request_id: Option<i64>,
2102 #[doc = "Resource Id"]
2103 #[serde(
2104 rename = "resourceId",
2105 default,
2106 skip_serializing_if = "Option::is_none"
2107 )]
2108 pub resource_id: Option<i32>,
2109 #[doc = "Result of the environment deployment execution"]
2110 #[serde(default, skip_serializing_if = "Option::is_none")]
2111 pub result: Option<environment_resource_deployment_execution_record::Result>,
2112 #[doc = "Start time of the environment resource deployment execution"]
2113 #[serde(
2114 rename = "startTime",
2115 default,
2116 skip_serializing_if = "Option::is_none",
2117 with = "crate::date_time::rfc3339::option"
2118 )]
2119 pub start_time: Option<time::OffsetDateTime>,
2120}
2121impl EnvironmentResourceDeploymentExecutionRecord {
2122 pub fn new() -> Self {
2123 Self::default()
2124 }
2125}
2126pub mod environment_resource_deployment_execution_record {
2127 use super::*;
2128 #[doc = "Result of the environment deployment execution"]
2129 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2130 pub enum Result {
2131 #[serde(rename = "succeeded")]
2132 Succeeded,
2133 #[serde(rename = "succeededWithIssues")]
2134 SucceededWithIssues,
2135 #[serde(rename = "failed")]
2136 Failed,
2137 #[serde(rename = "canceled")]
2138 Canceled,
2139 #[serde(rename = "skipped")]
2140 Skipped,
2141 #[serde(rename = "abandoned")]
2142 Abandoned,
2143 }
2144}
2145#[doc = "EnvironmentResourceReference."]
2146#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2147pub struct EnvironmentResourceReference {
2148 #[doc = "Id of the resource."]
2149 #[serde(default, skip_serializing_if = "Option::is_none")]
2150 pub id: Option<i32>,
2151 #[doc = "Name of the resource."]
2152 #[serde(default, skip_serializing_if = "Option::is_none")]
2153 pub name: Option<String>,
2154 #[doc = "Tags of the Environment Resource Reference."]
2155 #[serde(
2156 default,
2157 deserialize_with = "crate::serde::deserialize_null_as_default",
2158 skip_serializing_if = "Vec::is_empty"
2159 )]
2160 pub tags: Vec<String>,
2161 #[doc = "Type of the resource."]
2162 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
2163 pub type_: Option<environment_resource_reference::Type>,
2164}
2165impl EnvironmentResourceReference {
2166 pub fn new() -> Self {
2167 Self::default()
2168 }
2169}
2170pub mod environment_resource_reference {
2171 use super::*;
2172 #[doc = "Type of the resource."]
2173 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2174 pub enum Type {
2175 #[serde(rename = "undefined")]
2176 Undefined,
2177 #[serde(rename = "generic")]
2178 Generic,
2179 #[serde(rename = "virtualMachine")]
2180 VirtualMachine,
2181 #[serde(rename = "kubernetes")]
2182 Kubernetes,
2183 }
2184}
2185#[doc = "Properties to update Environment."]
2186#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2187pub struct EnvironmentUpdateParameter {
2188 #[doc = "Description of the environment."]
2189 #[serde(default, skip_serializing_if = "Option::is_none")]
2190 pub description: Option<String>,
2191 #[doc = "Name of the environment."]
2192 #[serde(default, skip_serializing_if = "Option::is_none")]
2193 pub name: Option<String>,
2194}
2195impl EnvironmentUpdateParameter {
2196 pub fn new() -> Self {
2197 Self::default()
2198 }
2199}
2200#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2201pub struct EventsConfig {}
2202impl EventsConfig {
2203 pub fn new() -> Self {
2204 Self::default()
2205 }
2206}
2207#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2208pub struct ExpressionValidationItem {
2209 #[serde(flatten)]
2210 pub validation_item: ValidationItem,
2211}
2212impl ExpressionValidationItem {
2213 pub fn new() -> Self {
2214 Self::default()
2215 }
2216}
2217#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2218pub struct GraphSubjectBase {
2219 #[doc = "Links"]
2220 #[serde(rename = "_links", default, skip_serializing_if = "Option::is_none")]
2221 pub links: Option<serde_json::Value>,
2222 #[doc = "The descriptor is the primary way to reference the graph subject while the system is running. This field will uniquely identify the same graph subject across both Accounts and Organizations."]
2223 #[serde(default, skip_serializing_if = "Option::is_none")]
2224 pub descriptor: Option<String>,
2225 #[doc = "This is the non-unique display name of the graph subject. To change this field, you must alter its value in the source provider."]
2226 #[serde(
2227 rename = "displayName",
2228 default,
2229 skip_serializing_if = "Option::is_none"
2230 )]
2231 pub display_name: Option<String>,
2232 #[doc = "This url is the full route to the source resource of this graph subject."]
2233 #[serde(default, skip_serializing_if = "Option::is_none")]
2234 pub url: Option<String>,
2235}
2236impl GraphSubjectBase {
2237 pub fn new() -> Self {
2238 Self::default()
2239 }
2240}
2241#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2242pub struct HelpLink {
2243 #[serde(default, skip_serializing_if = "Option::is_none")]
2244 pub text: Option<String>,
2245 #[serde(default, skip_serializing_if = "Option::is_none")]
2246 pub url: Option<String>,
2247}
2248impl HelpLink {
2249 pub fn new() -> Self {
2250 Self::default()
2251 }
2252}
2253#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2254pub struct IdentityRef {
2255 #[serde(flatten)]
2256 pub graph_subject_base: GraphSubjectBase,
2257 #[doc = "Deprecated - Can be retrieved by querying the Graph user referenced in the \"self\" entry of the IdentityRef \"_links\" dictionary"]
2258 #[serde(
2259 rename = "directoryAlias",
2260 default,
2261 skip_serializing_if = "Option::is_none"
2262 )]
2263 pub directory_alias: Option<String>,
2264 #[serde(default, skip_serializing_if = "Option::is_none")]
2265 pub id: Option<String>,
2266 #[doc = "Deprecated - Available in the \"avatar\" entry of the IdentityRef \"_links\" dictionary"]
2267 #[serde(rename = "imageUrl", default, skip_serializing_if = "Option::is_none")]
2268 pub image_url: Option<String>,
2269 #[doc = "Deprecated - Can be retrieved by querying the Graph membership state referenced in the \"membershipState\" entry of the GraphUser \"_links\" dictionary"]
2270 #[serde(default, skip_serializing_if = "Option::is_none")]
2271 pub inactive: Option<bool>,
2272 #[doc = "Deprecated - Can be inferred from the subject type of the descriptor (Descriptor.IsAadUserType/Descriptor.IsAadGroupType)"]
2273 #[serde(
2274 rename = "isAadIdentity",
2275 default,
2276 skip_serializing_if = "Option::is_none"
2277 )]
2278 pub is_aad_identity: Option<bool>,
2279 #[doc = "Deprecated - Can be inferred from the subject type of the descriptor (Descriptor.IsGroupType)"]
2280 #[serde(
2281 rename = "isContainer",
2282 default,
2283 skip_serializing_if = "Option::is_none"
2284 )]
2285 pub is_container: Option<bool>,
2286 #[serde(
2287 rename = "isDeletedInOrigin",
2288 default,
2289 skip_serializing_if = "Option::is_none"
2290 )]
2291 pub is_deleted_in_origin: Option<bool>,
2292 #[doc = "Deprecated - not in use in most preexisting implementations of ToIdentityRef"]
2293 #[serde(
2294 rename = "profileUrl",
2295 default,
2296 skip_serializing_if = "Option::is_none"
2297 )]
2298 pub profile_url: Option<String>,
2299 #[doc = "Deprecated - use Domain+PrincipalName instead"]
2300 #[serde(
2301 rename = "uniqueName",
2302 default,
2303 skip_serializing_if = "Option::is_none"
2304 )]
2305 pub unique_name: Option<String>,
2306}
2307impl IdentityRef {
2308 pub fn new() -> Self {
2309 Self::default()
2310 }
2311}
2312#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2313pub struct InputBindingContext {
2314 #[doc = "Value of the input"]
2315 #[serde(default, skip_serializing_if = "Option::is_none")]
2316 pub value: Option<String>,
2317}
2318impl InputBindingContext {
2319 pub fn new() -> Self {
2320 Self::default()
2321 }
2322}
2323#[doc = "Describes an input for subscriptions."]
2324#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2325pub struct InputDescriptor {
2326 #[doc = "The ids of all inputs that the value of this input is dependent on."]
2327 #[serde(
2328 rename = "dependencyInputIds",
2329 default,
2330 deserialize_with = "crate::serde::deserialize_null_as_default",
2331 skip_serializing_if = "Vec::is_empty"
2332 )]
2333 pub dependency_input_ids: Vec<String>,
2334 #[doc = "Description of what this input is used for"]
2335 #[serde(default, skip_serializing_if = "Option::is_none")]
2336 pub description: Option<String>,
2337 #[doc = "The group localized name to which this input belongs and can be shown as a header for the container that will include all the inputs in the group."]
2338 #[serde(rename = "groupName", default, skip_serializing_if = "Option::is_none")]
2339 pub group_name: Option<String>,
2340 #[doc = "If true, the value information for this input is dynamic and should be fetched when the value of dependency inputs change."]
2341 #[serde(
2342 rename = "hasDynamicValueInformation",
2343 default,
2344 skip_serializing_if = "Option::is_none"
2345 )]
2346 pub has_dynamic_value_information: Option<bool>,
2347 #[doc = "Identifier for the subscription input"]
2348 #[serde(default, skip_serializing_if = "Option::is_none")]
2349 pub id: Option<String>,
2350 #[doc = "Mode in which the value of this input should be entered"]
2351 #[serde(rename = "inputMode", default, skip_serializing_if = "Option::is_none")]
2352 pub input_mode: Option<input_descriptor::InputMode>,
2353 #[doc = "Gets whether this input is confidential, such as for a password or application key"]
2354 #[serde(
2355 rename = "isConfidential",
2356 default,
2357 skip_serializing_if = "Option::is_none"
2358 )]
2359 pub is_confidential: Option<bool>,
2360 #[doc = "Localized name which can be shown as a label for the subscription input"]
2361 #[serde(default, skip_serializing_if = "Option::is_none")]
2362 pub name: Option<String>,
2363 #[doc = "Custom properties for the input which can be used by the service provider"]
2364 #[serde(default, skip_serializing_if = "Option::is_none")]
2365 pub properties: Option<serde_json::Value>,
2366 #[doc = "Underlying data type for the input value. When this value is specified, InputMode, Validation and Values are optional."]
2367 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
2368 pub type_: Option<String>,
2369 #[doc = "Gets whether this input is included in the default generated action description."]
2370 #[serde(
2371 rename = "useInDefaultDescription",
2372 default,
2373 skip_serializing_if = "Option::is_none"
2374 )]
2375 pub use_in_default_description: Option<bool>,
2376 #[doc = "Describes what values are valid for a subscription input"]
2377 #[serde(default, skip_serializing_if = "Option::is_none")]
2378 pub validation: Option<InputValidation>,
2379 #[doc = "A hint for input value. It can be used in the UI as the input placeholder."]
2380 #[serde(rename = "valueHint", default, skip_serializing_if = "Option::is_none")]
2381 pub value_hint: Option<String>,
2382 #[doc = "Information about the possible/allowed values for a given subscription input"]
2383 #[serde(default, skip_serializing_if = "Option::is_none")]
2384 pub values: Option<InputValues>,
2385}
2386impl InputDescriptor {
2387 pub fn new() -> Self {
2388 Self::default()
2389 }
2390}
2391pub mod input_descriptor {
2392 use super::*;
2393 #[doc = "Mode in which the value of this input should be entered"]
2394 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2395 pub enum InputMode {
2396 #[serde(rename = "none")]
2397 None,
2398 #[serde(rename = "textBox")]
2399 TextBox,
2400 #[serde(rename = "passwordBox")]
2401 PasswordBox,
2402 #[serde(rename = "combo")]
2403 Combo,
2404 #[serde(rename = "radioButtons")]
2405 RadioButtons,
2406 #[serde(rename = "checkBox")]
2407 CheckBox,
2408 #[serde(rename = "textArea")]
2409 TextArea,
2410 }
2411}
2412#[doc = "Describes what values are valid for a subscription input"]
2413#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2414pub struct InputValidation {
2415 #[doc = "Gets or sets the data type to validate."]
2416 #[serde(rename = "dataType", default, skip_serializing_if = "Option::is_none")]
2417 pub data_type: Option<input_validation::DataType>,
2418 #[doc = "Gets or sets if this is a required field."]
2419 #[serde(
2420 rename = "isRequired",
2421 default,
2422 skip_serializing_if = "Option::is_none"
2423 )]
2424 pub is_required: Option<bool>,
2425 #[doc = "Gets or sets the maximum length of this descriptor."]
2426 #[serde(rename = "maxLength", default, skip_serializing_if = "Option::is_none")]
2427 pub max_length: Option<i32>,
2428 #[doc = "Gets or sets the minimum value for this descriptor."]
2429 #[serde(rename = "maxValue", default, skip_serializing_if = "Option::is_none")]
2430 pub max_value: Option<String>,
2431 #[doc = "Gets or sets the minimum length of this descriptor."]
2432 #[serde(rename = "minLength", default, skip_serializing_if = "Option::is_none")]
2433 pub min_length: Option<i32>,
2434 #[doc = "Gets or sets the minimum value for this descriptor."]
2435 #[serde(rename = "minValue", default, skip_serializing_if = "Option::is_none")]
2436 pub min_value: Option<String>,
2437 #[doc = "Gets or sets the pattern to validate."]
2438 #[serde(default, skip_serializing_if = "Option::is_none")]
2439 pub pattern: Option<String>,
2440 #[doc = "Gets or sets the error on pattern mismatch."]
2441 #[serde(
2442 rename = "patternMismatchErrorMessage",
2443 default,
2444 skip_serializing_if = "Option::is_none"
2445 )]
2446 pub pattern_mismatch_error_message: Option<String>,
2447}
2448impl InputValidation {
2449 pub fn new() -> Self {
2450 Self::default()
2451 }
2452}
2453pub mod input_validation {
2454 use super::*;
2455 #[doc = "Gets or sets the data type to validate."]
2456 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2457 pub enum DataType {
2458 #[serde(rename = "none")]
2459 None,
2460 #[serde(rename = "string")]
2461 String,
2462 #[serde(rename = "number")]
2463 Number,
2464 #[serde(rename = "boolean")]
2465 Boolean,
2466 #[serde(rename = "guid")]
2467 Guid,
2468 #[serde(rename = "uri")]
2469 Uri,
2470 }
2471}
2472#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2473pub struct InputValidationItem {
2474 #[serde(flatten)]
2475 pub validation_item: ValidationItem,
2476 #[serde(default, skip_serializing_if = "Option::is_none")]
2477 pub context: Option<InputBindingContext>,
2478}
2479impl InputValidationItem {
2480 pub fn new() -> Self {
2481 Self::default()
2482 }
2483}
2484#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2485pub struct InputValidationRequest {
2486 #[serde(default, skip_serializing_if = "Option::is_none")]
2487 pub inputs: Option<serde_json::Value>,
2488}
2489impl InputValidationRequest {
2490 pub fn new() -> Self {
2491 Self::default()
2492 }
2493}
2494#[doc = "Information about a single value for an input"]
2495#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2496pub struct InputValue {
2497 #[doc = "Any other data about this input"]
2498 #[serde(default, skip_serializing_if = "Option::is_none")]
2499 pub data: Option<serde_json::Value>,
2500 #[doc = "The text to show for the display of this value"]
2501 #[serde(
2502 rename = "displayValue",
2503 default,
2504 skip_serializing_if = "Option::is_none"
2505 )]
2506 pub display_value: Option<String>,
2507 #[doc = "The value to store for this input"]
2508 #[serde(default, skip_serializing_if = "Option::is_none")]
2509 pub value: Option<String>,
2510}
2511impl InputValue {
2512 pub fn new() -> Self {
2513 Self::default()
2514 }
2515}
2516#[doc = "Information about the possible/allowed values for a given subscription input"]
2517#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2518pub struct InputValues {
2519 #[doc = "The default value to use for this input"]
2520 #[serde(
2521 rename = "defaultValue",
2522 default,
2523 skip_serializing_if = "Option::is_none"
2524 )]
2525 pub default_value: Option<String>,
2526 #[doc = "Error information related to a subscription input value."]
2527 #[serde(default, skip_serializing_if = "Option::is_none")]
2528 pub error: Option<InputValuesError>,
2529 #[doc = "The id of the input"]
2530 #[serde(rename = "inputId", default, skip_serializing_if = "Option::is_none")]
2531 pub input_id: Option<String>,
2532 #[doc = "Should this input be disabled"]
2533 #[serde(
2534 rename = "isDisabled",
2535 default,
2536 skip_serializing_if = "Option::is_none"
2537 )]
2538 pub is_disabled: Option<bool>,
2539 #[doc = "Should the value be restricted to one of the values in the PossibleValues (True) or are the values in PossibleValues just a suggestion (False)"]
2540 #[serde(
2541 rename = "isLimitedToPossibleValues",
2542 default,
2543 skip_serializing_if = "Option::is_none"
2544 )]
2545 pub is_limited_to_possible_values: Option<bool>,
2546 #[doc = "Should this input be made read-only"]
2547 #[serde(
2548 rename = "isReadOnly",
2549 default,
2550 skip_serializing_if = "Option::is_none"
2551 )]
2552 pub is_read_only: Option<bool>,
2553 #[doc = "Possible values that this input can take"]
2554 #[serde(
2555 rename = "possibleValues",
2556 default,
2557 deserialize_with = "crate::serde::deserialize_null_as_default",
2558 skip_serializing_if = "Vec::is_empty"
2559 )]
2560 pub possible_values: Vec<InputValue>,
2561}
2562impl InputValues {
2563 pub fn new() -> Self {
2564 Self::default()
2565 }
2566}
2567#[doc = "Error information related to a subscription input value."]
2568#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2569pub struct InputValuesError {
2570 #[doc = "The error message."]
2571 #[serde(default, skip_serializing_if = "Option::is_none")]
2572 pub message: Option<String>,
2573}
2574impl InputValuesError {
2575 pub fn new() -> Self {
2576 Self::default()
2577 }
2578}
2579#[doc = "An issue (error, warning) associated with a pipeline run."]
2580#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2581pub struct Issue {
2582 #[doc = "The category of the issue. <br />Example: Code - refers to compilation errors <br />Example: General - refers to generic errors"]
2583 #[serde(default, skip_serializing_if = "Option::is_none")]
2584 pub category: Option<String>,
2585 #[doc = "A dictionary containing details about the issue."]
2586 #[serde(default, skip_serializing_if = "Option::is_none")]
2587 pub data: Option<serde_json::Value>,
2588 #[doc = "A description of issue."]
2589 #[serde(default, skip_serializing_if = "Option::is_none")]
2590 pub message: Option<String>,
2591 #[doc = "The type (error, warning) of the issue."]
2592 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
2593 pub type_: Option<issue::Type>,
2594}
2595impl Issue {
2596 pub fn new() -> Self {
2597 Self::default()
2598 }
2599}
2600pub mod issue {
2601 use super::*;
2602 #[doc = "The type (error, warning) of the issue."]
2603 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2604 pub enum Type {
2605 #[serde(rename = "error")]
2606 Error,
2607 #[serde(rename = "warning")]
2608 Warning,
2609 }
2610}
2611#[doc = "Represents a JSON object."]
2612#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2613pub struct JObject {
2614 #[serde(default, skip_serializing_if = "Option::is_none")]
2615 pub item: Option<String>,
2616 #[doc = "Gets the node type for this JToken."]
2617 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
2618 pub type_: Option<String>,
2619}
2620impl JObject {
2621 pub fn new() -> Self {
2622 Self::default()
2623 }
2624}
2625#[doc = "Represents an abstract JSON token."]
2626#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2627pub struct JToken {
2628 #[doc = "Represents an abstract JSON token."]
2629 #[serde(default, skip_serializing_if = "Option::is_none")]
2630 pub first: Option<Box<JToken>>,
2631 #[doc = "Gets a value indicating whether this token has child tokens."]
2632 #[serde(rename = "hasValues", default, skip_serializing_if = "Option::is_none")]
2633 pub has_values: Option<bool>,
2634 #[doc = "Represents an abstract JSON token."]
2635 #[serde(default, skip_serializing_if = "Option::is_none")]
2636 pub item: Option<Box<JToken>>,
2637 #[doc = "Represents an abstract JSON token."]
2638 #[serde(default, skip_serializing_if = "Option::is_none")]
2639 pub last: Option<Box<JToken>>,
2640 #[doc = "Represents an abstract JSON token."]
2641 #[serde(default, skip_serializing_if = "Option::is_none")]
2642 pub next: Option<Box<JToken>>,
2643 #[doc = "Gets or sets the parent."]
2644 #[serde(default, skip_serializing_if = "Option::is_none")]
2645 pub parent: Option<String>,
2646 #[doc = "Gets the path of the JSON token."]
2647 #[serde(default, skip_serializing_if = "Option::is_none")]
2648 pub path: Option<String>,
2649 #[doc = "Represents an abstract JSON token."]
2650 #[serde(default, skip_serializing_if = "Option::is_none")]
2651 pub previous: Option<Box<JToken>>,
2652 #[doc = "Represents an abstract JSON token."]
2653 #[serde(default, skip_serializing_if = "Option::is_none")]
2654 pub root: Option<Box<JToken>>,
2655 #[doc = "Gets the node type for this JToken."]
2656 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
2657 pub type_: Option<String>,
2658}
2659impl JToken {
2660 pub fn new() -> Self {
2661 Self::default()
2662 }
2663}
2664#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2665pub struct JobAssignedEvent {
2666 #[serde(flatten)]
2667 pub job_event: JobEvent,
2668 #[doc = "A job request for an agent."]
2669 #[serde(default, skip_serializing_if = "Option::is_none")]
2670 pub request: Option<TaskAgentJobRequest>,
2671}
2672impl JobAssignedEvent {
2673 pub fn new() -> Self {
2674 Self::default()
2675 }
2676}
2677#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2678pub struct JobCancelMessage {
2679 #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
2680 pub job_id: Option<String>,
2681 #[serde(default, skip_serializing_if = "Option::is_none")]
2682 pub timeout: Option<String>,
2683}
2684impl JobCancelMessage {
2685 pub fn new() -> Self {
2686 Self::default()
2687 }
2688}
2689#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2690pub struct JobCanceledEvent {
2691 #[serde(flatten)]
2692 pub job_event: JobEvent,
2693 #[doc = "The reason for job cancellation."]
2694 #[serde(default, skip_serializing_if = "Option::is_none")]
2695 pub reason: Option<String>,
2696 #[doc = "The job's timeout interval."]
2697 #[serde(default, skip_serializing_if = "Option::is_none")]
2698 pub timeout: Option<String>,
2699}
2700impl JobCanceledEvent {
2701 pub fn new() -> Self {
2702 Self::default()
2703 }
2704}
2705#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2706pub struct JobCompletedEvent {
2707 #[serde(flatten)]
2708 pub job_event: JobEvent,
2709 #[doc = "Indicates whether the agent is in the process of shutting down."]
2710 #[serde(
2711 rename = "agentShuttingDown",
2712 default,
2713 skip_serializing_if = "Option::is_none"
2714 )]
2715 pub agent_shutting_down: Option<bool>,
2716 #[doc = "The ID of the request."]
2717 #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
2718 pub request_id: Option<i64>,
2719 #[doc = "The result of the request."]
2720 #[serde(default, skip_serializing_if = "Option::is_none")]
2721 pub result: Option<job_completed_event::Result>,
2722}
2723impl JobCompletedEvent {
2724 pub fn new() -> Self {
2725 Self::default()
2726 }
2727}
2728pub mod job_completed_event {
2729 use super::*;
2730 #[doc = "The result of the request."]
2731 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
2732 pub enum Result {
2733 #[serde(rename = "succeeded")]
2734 Succeeded,
2735 #[serde(rename = "succeededWithIssues")]
2736 SucceededWithIssues,
2737 #[serde(rename = "failed")]
2738 Failed,
2739 #[serde(rename = "canceled")]
2740 Canceled,
2741 #[serde(rename = "skipped")]
2742 Skipped,
2743 #[serde(rename = "abandoned")]
2744 Abandoned,
2745 }
2746}
2747#[doc = "Represents the context of variables and vectors for a job request."]
2748#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2749pub struct JobEnvironment {
2750 #[serde(
2751 default,
2752 deserialize_with = "crate::serde::deserialize_null_as_default",
2753 skip_serializing_if = "Vec::is_empty"
2754 )]
2755 pub endpoints: Vec<ServiceEndpoint>,
2756 #[serde(
2757 default,
2758 deserialize_with = "crate::serde::deserialize_null_as_default",
2759 skip_serializing_if = "Vec::is_empty"
2760 )]
2761 pub mask: Vec<MaskHint>,
2762 #[serde(default, skip_serializing_if = "Option::is_none")]
2763 pub options: Option<serde_json::Value>,
2764 #[serde(
2765 rename = "secureFiles",
2766 default,
2767 deserialize_with = "crate::serde::deserialize_null_as_default",
2768 skip_serializing_if = "Vec::is_empty"
2769 )]
2770 pub secure_files: Vec<SecureFile>,
2771 #[doc = "Represents an endpoint which may be used by an orchestration job."]
2772 #[serde(
2773 rename = "systemConnection",
2774 default,
2775 skip_serializing_if = "Option::is_none"
2776 )]
2777 pub system_connection: Option<ServiceEndpoint>,
2778 #[serde(default, skip_serializing_if = "Option::is_none")]
2779 pub variables: Option<serde_json::Value>,
2780}
2781impl JobEnvironment {
2782 pub fn new() -> Self {
2783 Self::default()
2784 }
2785}
2786#[doc = "A pipeline job event to be processed by the execution plan."]
2787#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2788pub struct JobEvent {
2789 #[doc = "The ID of the pipeline job affected by the event."]
2790 #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
2791 pub job_id: Option<String>,
2792 #[doc = "The name of the pipeline job event."]
2793 #[serde(default, skip_serializing_if = "Option::is_none")]
2794 pub name: Option<String>,
2795}
2796impl JobEvent {
2797 pub fn new() -> Self {
2798 Self::default()
2799 }
2800}
2801#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2802pub struct JobEventConfig {
2803 #[serde(default, skip_serializing_if = "Option::is_none")]
2804 pub timeout: Option<String>,
2805}
2806impl JobEventConfig {
2807 pub fn new() -> Self {
2808 Self::default()
2809 }
2810}
2811#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2812pub struct JobEventsConfig {
2813 #[serde(
2814 rename = "jobAssigned",
2815 default,
2816 skip_serializing_if = "Option::is_none"
2817 )]
2818 pub job_assigned: Option<JobEventConfig>,
2819 #[serde(
2820 rename = "jobCompleted",
2821 default,
2822 skip_serializing_if = "Option::is_none"
2823 )]
2824 pub job_completed: Option<JobEventConfig>,
2825 #[serde(
2826 rename = "jobStarted",
2827 default,
2828 skip_serializing_if = "Option::is_none"
2829 )]
2830 pub job_started: Option<JobEventConfig>,
2831}
2832impl JobEventsConfig {
2833 pub fn new() -> Self {
2834 Self::default()
2835 }
2836}
2837#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2838pub struct JobMetadataEvent {
2839 #[serde(flatten)]
2840 pub job_event: JobEvent,
2841 #[doc = "A message to be sent to an agent currently running the job."]
2842 #[serde(default, skip_serializing_if = "Option::is_none")]
2843 pub message: Option<JobMetadataMessage>,
2844}
2845impl JobMetadataEvent {
2846 pub fn new() -> Self {
2847 Self::default()
2848 }
2849}
2850#[doc = "A message to be sent to an agent currently running the job."]
2851#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2852pub struct JobMetadataMessage {
2853 #[doc = "The id of the job."]
2854 #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
2855 pub job_id: Option<String>,
2856 #[doc = "The agent's frequency of posting lines to the logs console expressed in milliseconds. There are 2 modes: Slow (10 seconds) and Fast (half a second)."]
2857 #[serde(
2858 rename = "postLinesFrequencyMillis",
2859 default,
2860 skip_serializing_if = "Option::is_none"
2861 )]
2862 pub post_lines_frequency_millis: Option<i32>,
2863}
2864impl JobMetadataMessage {
2865 pub fn new() -> Self {
2866 Self::default()
2867 }
2868}
2869#[doc = "Represents an option that may affect the way an agent runs the job."]
2870#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2871pub struct JobOption {
2872 #[serde(default, skip_serializing_if = "Option::is_none")]
2873 pub data: Option<serde_json::Value>,
2874 #[doc = "Gets the id of the option."]
2875 #[serde(default, skip_serializing_if = "Option::is_none")]
2876 pub id: Option<String>,
2877}
2878impl JobOption {
2879 pub fn new() -> Self {
2880 Self::default()
2881 }
2882}
2883#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2884pub struct JobRequestMessage {
2885 #[doc = "Represents the context of variables and vectors for a job request."]
2886 #[serde(default, skip_serializing_if = "Option::is_none")]
2887 pub environment: Option<JobEnvironment>,
2888 #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
2889 pub job_id: Option<String>,
2890 #[serde(rename = "jobName", default, skip_serializing_if = "Option::is_none")]
2891 pub job_name: Option<String>,
2892 #[serde(
2893 rename = "jobRefName",
2894 default,
2895 skip_serializing_if = "Option::is_none"
2896 )]
2897 pub job_ref_name: Option<String>,
2898 #[serde(
2899 rename = "messageType",
2900 default,
2901 skip_serializing_if = "Option::is_none"
2902 )]
2903 pub message_type: Option<String>,
2904 #[serde(default, skip_serializing_if = "Option::is_none")]
2905 pub plan: Option<TaskOrchestrationPlanReference>,
2906 #[doc = "A reference to a timeline."]
2907 #[serde(default, skip_serializing_if = "Option::is_none")]
2908 pub timeline: Option<TimelineReference>,
2909}
2910impl JobRequestMessage {
2911 pub fn new() -> Self {
2912 Self::default()
2913 }
2914}
2915#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2916pub struct JobStartedEvent {
2917 #[serde(flatten)]
2918 pub job_event: JobEvent,
2919}
2920impl JobStartedEvent {
2921 pub fn new() -> Self {
2922 Self::default()
2923 }
2924}
2925#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2926pub struct KubernetesResource {
2927 #[serde(flatten)]
2928 pub environment_resource: EnvironmentResource,
2929 #[serde(
2930 rename = "clusterName",
2931 default,
2932 skip_serializing_if = "Option::is_none"
2933 )]
2934 pub cluster_name: Option<String>,
2935 #[serde(default, skip_serializing_if = "Option::is_none")]
2936 pub namespace: Option<String>,
2937 #[serde(
2938 rename = "serviceEndpointId",
2939 default,
2940 skip_serializing_if = "Option::is_none"
2941 )]
2942 pub service_endpoint_id: Option<String>,
2943}
2944impl KubernetesResource {
2945 pub fn new() -> Self {
2946 Self::default()
2947 }
2948}
2949#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2950pub struct KubernetesResourceCreateParameters {
2951 #[serde(
2952 rename = "clusterName",
2953 default,
2954 skip_serializing_if = "Option::is_none"
2955 )]
2956 pub cluster_name: Option<String>,
2957 #[serde(default, skip_serializing_if = "Option::is_none")]
2958 pub name: Option<String>,
2959 #[serde(default, skip_serializing_if = "Option::is_none")]
2960 pub namespace: Option<String>,
2961 #[doc = "Tags of the kubernetes resource."]
2962 #[serde(
2963 default,
2964 deserialize_with = "crate::serde::deserialize_null_as_default",
2965 skip_serializing_if = "Vec::is_empty"
2966 )]
2967 pub tags: Vec<String>,
2968}
2969impl KubernetesResourceCreateParameters {
2970 pub fn new() -> Self {
2971 Self::default()
2972 }
2973}
2974#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2975pub struct KubernetesResourceCreateParametersExistingEndpoint {
2976 #[serde(flatten)]
2977 pub kubernetes_resource_create_parameters: KubernetesResourceCreateParameters,
2978 #[serde(
2979 rename = "serviceEndpointId",
2980 default,
2981 skip_serializing_if = "Option::is_none"
2982 )]
2983 pub service_endpoint_id: Option<String>,
2984}
2985impl KubernetesResourceCreateParametersExistingEndpoint {
2986 pub fn new() -> Self {
2987 Self::default()
2988 }
2989}
2990#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
2991pub struct KubernetesResourceCreateParametersNewEndpoint {
2992 #[serde(flatten)]
2993 pub kubernetes_resource_create_parameters: KubernetesResourceCreateParameters,
2994 #[doc = "Represents an endpoint which may be used by an orchestration job."]
2995 #[serde(default, skip_serializing_if = "Option::is_none")]
2996 pub endpoint: Option<ServiceEndpoint>,
2997}
2998impl KubernetesResourceCreateParametersNewEndpoint {
2999 pub fn new() -> Self {
3000 Self::default()
3001 }
3002}
3003#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3004pub struct KubernetesResourcePatchParameters {
3005 #[serde(
3006 rename = "authorizationParameters",
3007 default,
3008 skip_serializing_if = "Option::is_none"
3009 )]
3010 pub authorization_parameters: Option<serde_json::Value>,
3011 #[doc = "Provider type (CustomProvider or AzureKubernetesServiceProvider) of the resource to be updated"]
3012 #[serde(
3013 rename = "providerType",
3014 default,
3015 skip_serializing_if = "Option::is_none"
3016 )]
3017 pub provider_type: Option<String>,
3018 #[serde(
3019 rename = "resourceId",
3020 default,
3021 skip_serializing_if = "Option::is_none"
3022 )]
3023 pub resource_id: Option<i32>,
3024}
3025impl KubernetesResourcePatchParameters {
3026 pub fn new() -> Self {
3027 Self::default()
3028 }
3029}
3030#[doc = "Represents a purchase of resource units in a secondary marketplace."]
3031#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3032pub struct MarketplacePurchasedLicense {
3033 #[doc = "The Marketplace display name."]
3034 #[serde(
3035 rename = "marketplaceName",
3036 default,
3037 skip_serializing_if = "Option::is_none"
3038 )]
3039 pub marketplace_name: Option<String>,
3040 #[doc = "The name of the identity making the purchase as seen by the marketplace"]
3041 #[serde(
3042 rename = "purchaserName",
3043 default,
3044 skip_serializing_if = "Option::is_none"
3045 )]
3046 pub purchaser_name: Option<String>,
3047 #[doc = "The quantity purchased."]
3048 #[serde(
3049 rename = "purchaseUnitCount",
3050 default,
3051 skip_serializing_if = "Option::is_none"
3052 )]
3053 pub purchase_unit_count: Option<i32>,
3054}
3055impl MarketplacePurchasedLicense {
3056 pub fn new() -> Self {
3057 Self::default()
3058 }
3059}
3060#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3061pub struct MaskHint {
3062 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
3063 pub type_: Option<mask_hint::Type>,
3064 #[serde(default, skip_serializing_if = "Option::is_none")]
3065 pub value: Option<String>,
3066}
3067impl MaskHint {
3068 pub fn new() -> Self {
3069 Self::default()
3070 }
3071}
3072pub mod mask_hint {
3073 use super::*;
3074 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3075 pub enum Type {
3076 #[serde(rename = "variable")]
3077 Variable,
3078 #[serde(rename = "regex")]
3079 Regex,
3080 }
3081}
3082#[doc = "Meta data for a metrics column."]
3083#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3084pub struct MetricsColumnMetaData {
3085 #[doc = "Name."]
3086 #[serde(
3087 rename = "columnName",
3088 default,
3089 skip_serializing_if = "Option::is_none"
3090 )]
3091 pub column_name: Option<String>,
3092 #[doc = "Data type."]
3093 #[serde(
3094 rename = "columnValueType",
3095 default,
3096 skip_serializing_if = "Option::is_none"
3097 )]
3098 pub column_value_type: Option<String>,
3099}
3100impl MetricsColumnMetaData {
3101 pub fn new() -> Self {
3102 Self::default()
3103 }
3104}
3105#[doc = "Metrics columns header"]
3106#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3107pub struct MetricsColumnsHeader {
3108 #[doc = "Properties of deployment group for which metrics are provided. E.g. 1: LastJobStatus E.g. 2: TargetState"]
3109 #[serde(
3110 default,
3111 deserialize_with = "crate::serde::deserialize_null_as_default",
3112 skip_serializing_if = "Vec::is_empty"
3113 )]
3114 pub dimensions: Vec<MetricsColumnMetaData>,
3115 #[doc = "The types of metrics. E.g. 1: total count of deployment targets. E.g. 2: Average time of deployment to the deployment targets."]
3116 #[serde(
3117 default,
3118 deserialize_with = "crate::serde::deserialize_null_as_default",
3119 skip_serializing_if = "Vec::is_empty"
3120 )]
3121 pub metrics: Vec<MetricsColumnMetaData>,
3122}
3123impl MetricsColumnsHeader {
3124 pub fn new() -> Self {
3125 Self::default()
3126 }
3127}
3128#[doc = "Metrics row."]
3129#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3130pub struct MetricsRow {
3131 #[doc = "The values of the properties mentioned as 'Dimensions' in column header. E.g. 1: For a property 'LastJobStatus' - metrics will be provided for 'passed', 'failed', etc. E.g. 2: For a property 'TargetState' - metrics will be provided for 'online', 'offline' targets."]
3132 #[serde(
3133 default,
3134 deserialize_with = "crate::serde::deserialize_null_as_default",
3135 skip_serializing_if = "Vec::is_empty"
3136 )]
3137 pub dimensions: Vec<String>,
3138 #[doc = "Metrics in serialized format. Should be deserialized based on the data type provided in header."]
3139 #[serde(
3140 default,
3141 deserialize_with = "crate::serde::deserialize_null_as_default",
3142 skip_serializing_if = "Vec::is_empty"
3143 )]
3144 pub metrics: Vec<String>,
3145}
3146impl MetricsRow {
3147 pub fn new() -> Self {
3148 Self::default()
3149 }
3150}
3151#[doc = "Represents a downloadable package."]
3152#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3153pub struct PackageMetadata {
3154 #[doc = "The date the package was created"]
3155 #[serde(
3156 rename = "createdOn",
3157 default,
3158 skip_serializing_if = "Option::is_none",
3159 with = "crate::date_time::rfc3339::option"
3160 )]
3161 pub created_on: Option<time::OffsetDateTime>,
3162 #[doc = "A direct link to download the package."]
3163 #[serde(
3164 rename = "downloadUrl",
3165 default,
3166 skip_serializing_if = "Option::is_none"
3167 )]
3168 pub download_url: Option<String>,
3169 #[doc = "The UI uses this to display instructions, i.e. \"unzip MyAgent.zip\""]
3170 #[serde(default, skip_serializing_if = "Option::is_none")]
3171 pub filename: Option<String>,
3172 #[doc = "MD5 hash as a base64 string"]
3173 #[serde(rename = "hashValue", default, skip_serializing_if = "Option::is_none")]
3174 pub hash_value: Option<String>,
3175 #[doc = "A link to documentation"]
3176 #[serde(rename = "infoUrl", default, skip_serializing_if = "Option::is_none")]
3177 pub info_url: Option<String>,
3178 #[doc = "The platform (win7, linux, etc.)"]
3179 #[serde(default, skip_serializing_if = "Option::is_none")]
3180 pub platform: Option<String>,
3181 #[doc = "The type of package (e.g. \"agent\")"]
3182 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
3183 pub type_: Option<String>,
3184 #[serde(default, skip_serializing_if = "Option::is_none")]
3185 pub version: Option<PackageVersion>,
3186}
3187impl PackageMetadata {
3188 pub fn new() -> Self {
3189 Self::default()
3190 }
3191}
3192#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3193pub struct PackageVersion {
3194 #[serde(default, skip_serializing_if = "Option::is_none")]
3195 pub major: Option<i32>,
3196 #[serde(default, skip_serializing_if = "Option::is_none")]
3197 pub minor: Option<i32>,
3198 #[serde(default, skip_serializing_if = "Option::is_none")]
3199 pub patch: Option<i32>,
3200}
3201impl PackageVersion {
3202 pub fn new() -> Self {
3203 Self::default()
3204 }
3205}
3206#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3207pub struct PlanEnvironment {
3208 #[serde(
3209 default,
3210 deserialize_with = "crate::serde::deserialize_null_as_default",
3211 skip_serializing_if = "Vec::is_empty"
3212 )]
3213 pub mask: Vec<MaskHint>,
3214 #[serde(default, skip_serializing_if = "Option::is_none")]
3215 pub options: Option<serde_json::Value>,
3216 #[serde(default, skip_serializing_if = "Option::is_none")]
3217 pub variables: Option<serde_json::Value>,
3218}
3219impl PlanEnvironment {
3220 pub fn new() -> Self {
3221 Self::default()
3222 }
3223}
3224#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3225pub struct ProjectReference {
3226 #[serde(default, skip_serializing_if = "Option::is_none")]
3227 pub id: Option<String>,
3228 #[serde(default, skip_serializing_if = "Option::is_none")]
3229 pub name: Option<String>,
3230}
3231impl ProjectReference {
3232 pub fn new() -> Self {
3233 Self::default()
3234 }
3235}
3236#[doc = "The class represents a property bag as a collection of key-value pairs. Values of all primitive types (any type with a `TypeCode != TypeCode.Object`) except for `DBNull` are accepted. Values of type Byte[], Int32, Double, DateType and String preserve their type, other primitives are retuned as a String. Byte[] expected as base64 encoded string."]
3237#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3238pub struct PropertiesCollection {
3239 #[doc = "The count of properties in the collection."]
3240 #[serde(default, skip_serializing_if = "Option::is_none")]
3241 pub count: Option<i32>,
3242 #[serde(default, skip_serializing_if = "Option::is_none")]
3243 pub item: Option<serde_json::Value>,
3244 #[doc = "The set of keys in the collection."]
3245 #[serde(
3246 default,
3247 deserialize_with = "crate::serde::deserialize_null_as_default",
3248 skip_serializing_if = "Vec::is_empty"
3249 )]
3250 pub keys: Vec<String>,
3251 #[doc = "The set of values in the collection."]
3252 #[serde(
3253 default,
3254 deserialize_with = "crate::serde::deserialize_null_as_default",
3255 skip_serializing_if = "Vec::is_empty"
3256 )]
3257 pub values: Vec<String>,
3258}
3259impl PropertiesCollection {
3260 pub fn new() -> Self {
3261 Self::default()
3262 }
3263}
3264#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3265pub struct PublishTaskGroupMetadata {
3266 #[serde(default, skip_serializing_if = "Option::is_none")]
3267 pub comment: Option<String>,
3268 #[serde(
3269 rename = "parentDefinitionRevision",
3270 default,
3271 skip_serializing_if = "Option::is_none"
3272 )]
3273 pub parent_definition_revision: Option<i32>,
3274 #[serde(default, skip_serializing_if = "Option::is_none")]
3275 pub preview: Option<bool>,
3276 #[serde(
3277 rename = "taskGroupId",
3278 default,
3279 skip_serializing_if = "Option::is_none"
3280 )]
3281 pub task_group_id: Option<String>,
3282 #[serde(
3283 rename = "taskGroupRevision",
3284 default,
3285 skip_serializing_if = "Option::is_none"
3286 )]
3287 pub task_group_revision: Option<i32>,
3288}
3289impl PublishTaskGroupMetadata {
3290 pub fn new() -> Self {
3291 Self::default()
3292 }
3293}
3294#[doc = "The class to represent a collection of REST reference links."]
3295#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3296pub struct ReferenceLinks {
3297 #[doc = "The readonly view of the links. Because Reference links are readonly, we only want to expose them as read only."]
3298 #[serde(default, skip_serializing_if = "Option::is_none")]
3299 pub links: Option<serde_json::Value>,
3300}
3301impl ReferenceLinks {
3302 pub fn new() -> Self {
3303 Self::default()
3304 }
3305}
3306#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3307pub struct ResourceFilterOptions {
3308 #[serde(
3309 default,
3310 deserialize_with = "crate::serde::deserialize_null_as_default",
3311 skip_serializing_if = "Vec::is_empty"
3312 )]
3313 pub identities: Vec<IdentityRef>,
3314 #[serde(
3315 rename = "resourceTypes",
3316 default,
3317 deserialize_with = "crate::serde::deserialize_null_as_default",
3318 skip_serializing_if = "Vec::is_empty"
3319 )]
3320 pub resource_types: Vec<String>,
3321}
3322impl ResourceFilterOptions {
3323 pub fn new() -> Self {
3324 Self::default()
3325 }
3326}
3327#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3328pub struct ResourceFilters {
3329 #[serde(
3330 rename = "createdBy",
3331 default,
3332 deserialize_with = "crate::serde::deserialize_null_as_default",
3333 skip_serializing_if = "Vec::is_empty"
3334 )]
3335 pub created_by: Vec<String>,
3336 #[serde(
3337 rename = "resourceType",
3338 default,
3339 deserialize_with = "crate::serde::deserialize_null_as_default",
3340 skip_serializing_if = "Vec::is_empty"
3341 )]
3342 pub resource_type: Vec<String>,
3343 #[serde(
3344 rename = "searchText",
3345 default,
3346 skip_serializing_if = "Option::is_none"
3347 )]
3348 pub search_text: Option<String>,
3349}
3350impl ResourceFilters {
3351 pub fn new() -> Self {
3352 Self::default()
3353 }
3354}
3355#[doc = "Resources include Service Connections, Variable Groups and Secure Files."]
3356#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3357pub struct ResourceItem {
3358 #[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
3359 pub created_by: Option<IdentityRef>,
3360 #[doc = "Gets or sets description of the resource."]
3361 #[serde(default, skip_serializing_if = "Option::is_none")]
3362 pub description: Option<String>,
3363 #[doc = "Gets or sets icon url of the resource."]
3364 #[serde(rename = "iconUrl", default, skip_serializing_if = "Option::is_none")]
3365 pub icon_url: Option<String>,
3366 #[doc = "Gets or sets Id of the resource."]
3367 #[serde(default, skip_serializing_if = "Option::is_none")]
3368 pub id: Option<String>,
3369 #[doc = "Indicates whether resource is shared with other projects or not."]
3370 #[serde(rename = "isShared", default, skip_serializing_if = "Option::is_none")]
3371 pub is_shared: Option<bool>,
3372 #[doc = "Gets or sets name of the resource."]
3373 #[serde(default, skip_serializing_if = "Option::is_none")]
3374 pub name: Option<String>,
3375 #[doc = "Gets or sets internal properties of the resource."]
3376 #[serde(default, skip_serializing_if = "Option::is_none")]
3377 pub properties: Option<serde_json::Value>,
3378 #[doc = "Gets or sets resource type."]
3379 #[serde(
3380 rename = "resourceType",
3381 default,
3382 skip_serializing_if = "Option::is_none"
3383 )]
3384 pub resource_type: Option<String>,
3385}
3386impl ResourceItem {
3387 pub fn new() -> Self {
3388 Self::default()
3389 }
3390}
3391#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3392pub struct ResourceLimit {
3393 #[serde(
3394 rename = "failedToReachAllProviders",
3395 default,
3396 skip_serializing_if = "Option::is_none"
3397 )]
3398 pub failed_to_reach_all_providers: Option<bool>,
3399 #[serde(rename = "hostId", default, skip_serializing_if = "Option::is_none")]
3400 pub host_id: Option<String>,
3401 #[serde(rename = "isHosted", default, skip_serializing_if = "Option::is_none")]
3402 pub is_hosted: Option<bool>,
3403 #[serde(rename = "isPremium", default, skip_serializing_if = "Option::is_none")]
3404 pub is_premium: Option<bool>,
3405 #[serde(
3406 rename = "parallelismTag",
3407 default,
3408 skip_serializing_if = "Option::is_none"
3409 )]
3410 pub parallelism_tag: Option<String>,
3411 #[serde(
3412 rename = "resourceLimitsData",
3413 default,
3414 skip_serializing_if = "Option::is_none"
3415 )]
3416 pub resource_limits_data: Option<serde_json::Value>,
3417 #[serde(
3418 rename = "totalCount",
3419 default,
3420 skip_serializing_if = "Option::is_none"
3421 )]
3422 pub total_count: Option<i32>,
3423 #[serde(
3424 rename = "totalMinutes",
3425 default,
3426 skip_serializing_if = "Option::is_none"
3427 )]
3428 pub total_minutes: Option<i32>,
3429}
3430impl ResourceLimit {
3431 pub fn new() -> Self {
3432 Self::default()
3433 }
3434}
3435#[doc = "A request for a resource's exclusive lock"]
3436#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3437pub struct ResourceLockRequest {
3438 #[doc = "The date/time this request was assigned."]
3439 #[serde(
3440 rename = "assignTime",
3441 default,
3442 skip_serializing_if = "Option::is_none",
3443 with = "crate::date_time::rfc3339::option"
3444 )]
3445 pub assign_time: Option<time::OffsetDateTime>,
3446 #[doc = "The ID of the check run waiting on this request"]
3447 #[serde(
3448 rename = "checkRunId",
3449 default,
3450 skip_serializing_if = "Option::is_none"
3451 )]
3452 pub check_run_id: Option<String>,
3453 #[doc = "The ID of the pipeline that requested this resource"]
3454 #[serde(
3455 rename = "definitionId",
3456 default,
3457 skip_serializing_if = "Option::is_none"
3458 )]
3459 pub definition_id: Option<i32>,
3460 #[doc = "The date/time this request was finished."]
3461 #[serde(
3462 rename = "finishTime",
3463 default,
3464 skip_serializing_if = "Option::is_none",
3465 with = "crate::date_time::rfc3339::option"
3466 )]
3467 pub finish_time: Option<time::OffsetDateTime>,
3468 #[doc = "The behavior this request should exhibit in relation to other lock requests"]
3469 #[serde(rename = "lockType", default, skip_serializing_if = "Option::is_none")]
3470 pub lock_type: Option<resource_lock_request::LockType>,
3471 #[doc = "Attempt of the graph node"]
3472 #[serde(
3473 rename = "nodeAttempt",
3474 default,
3475 skip_serializing_if = "Option::is_none"
3476 )]
3477 pub node_attempt: Option<i32>,
3478 #[doc = "Name of the graph node (currently stage) requesting this resource"]
3479 #[serde(rename = "nodeName", default, skip_serializing_if = "Option::is_none")]
3480 pub node_name: Option<String>,
3481 #[doc = "Internal ID for the orchestration plan connected with this request."]
3482 #[serde(rename = "planId", default, skip_serializing_if = "Option::is_none")]
3483 pub plan_id: Option<String>,
3484 #[doc = "The ID of the project of the check run and definition exist in"]
3485 #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
3486 pub project_id: Option<String>,
3487 #[doc = "The date/time this request was queued."]
3488 #[serde(
3489 rename = "queueTime",
3490 default,
3491 skip_serializing_if = "Option::is_none",
3492 with = "crate::date_time::rfc3339::option"
3493 )]
3494 pub queue_time: Option<time::OffsetDateTime>,
3495 #[doc = "ID of the request."]
3496 #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
3497 pub request_id: Option<i64>,
3498 #[doc = "The id of the resource"]
3499 #[serde(
3500 rename = "resourceId",
3501 default,
3502 skip_serializing_if = "Option::is_none"
3503 )]
3504 pub resource_id: Option<String>,
3505 #[doc = "The type of the resource"]
3506 #[serde(
3507 rename = "resourceType",
3508 default,
3509 skip_serializing_if = "Option::is_none"
3510 )]
3511 pub resource_type: Option<String>,
3512 #[doc = "The result of this request."]
3513 #[serde(default, skip_serializing_if = "Option::is_none")]
3514 pub status: Option<resource_lock_request::Status>,
3515}
3516impl ResourceLockRequest {
3517 pub fn new() -> Self {
3518 Self::default()
3519 }
3520}
3521pub mod resource_lock_request {
3522 use super::*;
3523 #[doc = "The behavior this request should exhibit in relation to other lock requests"]
3524 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3525 pub enum LockType {
3526 #[serde(rename = "runLatest")]
3527 RunLatest,
3528 #[serde(rename = "sequential")]
3529 Sequential,
3530 }
3531 #[doc = "The result of this request."]
3532 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3533 pub enum Status {
3534 #[serde(rename = "queued")]
3535 Queued,
3536 #[serde(rename = "inUse")]
3537 InUse,
3538 #[serde(rename = "finished")]
3539 Finished,
3540 #[serde(rename = "timedOut")]
3541 TimedOut,
3542 #[serde(rename = "canceled")]
3543 Canceled,
3544 #[serde(rename = "abandoned")]
3545 Abandoned,
3546 #[serde(rename = "waitingOnChecks")]
3547 WaitingOnChecks,
3548 }
3549}
3550#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3551pub struct ResourceUsage {
3552 #[serde(
3553 rename = "resourceLimit",
3554 default,
3555 skip_serializing_if = "Option::is_none"
3556 )]
3557 pub resource_limit: Option<ResourceLimit>,
3558 #[serde(
3559 rename = "runningRequests",
3560 default,
3561 deserialize_with = "crate::serde::deserialize_null_as_default",
3562 skip_serializing_if = "Vec::is_empty"
3563 )]
3564 pub running_requests: Vec<TaskAgentJobRequest>,
3565 #[serde(rename = "usedCount", default, skip_serializing_if = "Option::is_none")]
3566 pub used_count: Option<i32>,
3567 #[serde(
3568 rename = "usedMinutes",
3569 default,
3570 skip_serializing_if = "Option::is_none"
3571 )]
3572 pub used_minutes: Option<i32>,
3573}
3574impl ResourceUsage {
3575 pub fn new() -> Self {
3576 Self::default()
3577 }
3578}
3579#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3580pub struct ResourcesHubData {
3581 #[serde(
3582 rename = "continuationToken",
3583 default,
3584 skip_serializing_if = "Option::is_none"
3585 )]
3586 pub continuation_token: Option<String>,
3587 #[serde(
3588 rename = "hasProjectLevelManagePermission",
3589 default,
3590 skip_serializing_if = "Option::is_none"
3591 )]
3592 pub has_project_level_manage_permission: Option<bool>,
3593 #[serde(
3594 rename = "resourceFilterOptions",
3595 default,
3596 skip_serializing_if = "Option::is_none"
3597 )]
3598 pub resource_filter_options: Option<ResourceFilterOptions>,
3599 #[serde(
3600 rename = "resourceFilters",
3601 default,
3602 skip_serializing_if = "Option::is_none"
3603 )]
3604 pub resource_filters: Option<ResourceFilters>,
3605 #[serde(
3606 rename = "resourceItems",
3607 default,
3608 deserialize_with = "crate::serde::deserialize_null_as_default",
3609 skip_serializing_if = "Vec::is_empty"
3610 )]
3611 pub resource_items: Vec<ResourceItem>,
3612}
3613impl ResourcesHubData {
3614 pub fn new() -> Self {
3615 Self::default()
3616 }
3617}
3618#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3619pub struct ResultTransformationDetails {
3620 #[serde(
3621 rename = "resultTemplate",
3622 default,
3623 skip_serializing_if = "Option::is_none"
3624 )]
3625 pub result_template: Option<String>,
3626}
3627impl ResultTransformationDetails {
3628 pub fn new() -> Self {
3629 Self::default()
3630 }
3631}
3632#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3633pub struct SecureFile {
3634 #[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
3635 pub created_by: Option<IdentityRef>,
3636 #[serde(
3637 rename = "createdOn",
3638 default,
3639 skip_serializing_if = "Option::is_none",
3640 with = "crate::date_time::rfc3339::option"
3641 )]
3642 pub created_on: Option<time::OffsetDateTime>,
3643 #[serde(default, skip_serializing_if = "Option::is_none")]
3644 pub id: Option<String>,
3645 #[serde(
3646 rename = "modifiedBy",
3647 default,
3648 skip_serializing_if = "Option::is_none"
3649 )]
3650 pub modified_by: Option<IdentityRef>,
3651 #[serde(
3652 rename = "modifiedOn",
3653 default,
3654 skip_serializing_if = "Option::is_none",
3655 with = "crate::date_time::rfc3339::option"
3656 )]
3657 pub modified_on: Option<time::OffsetDateTime>,
3658 #[serde(default, skip_serializing_if = "Option::is_none")]
3659 pub name: Option<String>,
3660 #[serde(default, skip_serializing_if = "Option::is_none")]
3661 pub properties: Option<serde_json::Value>,
3662 #[serde(default, skip_serializing_if = "Option::is_none")]
3663 pub ticket: Option<String>,
3664}
3665impl SecureFile {
3666 pub fn new() -> Self {
3667 Self::default()
3668 }
3669}
3670#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3671pub struct SecureFileEvent {
3672 #[serde(rename = "eventType", default, skip_serializing_if = "Option::is_none")]
3673 pub event_type: Option<String>,
3674 #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
3675 pub project_id: Option<String>,
3676 #[serde(
3677 rename = "secureFiles",
3678 default,
3679 deserialize_with = "crate::serde::deserialize_null_as_default",
3680 skip_serializing_if = "Vec::is_empty"
3681 )]
3682 pub secure_files: Vec<SecureFile>,
3683}
3684impl SecureFileEvent {
3685 pub fn new() -> Self {
3686 Self::default()
3687 }
3688}
3689#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3690pub struct SendJobResponse {
3691 #[serde(default, skip_serializing_if = "Option::is_none")]
3692 pub events: Option<JobEventsConfig>,
3693 #[serde(default, skip_serializing_if = "Option::is_none")]
3694 pub variables: Option<serde_json::Value>,
3695}
3696impl SendJobResponse {
3697 pub fn new() -> Self {
3698 Self::default()
3699 }
3700}
3701#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3702pub struct ServerExecutionDefinition {
3703 #[serde(default, skip_serializing_if = "Option::is_none")]
3704 pub events: Option<EventsConfig>,
3705 #[serde(
3706 rename = "handlerName",
3707 default,
3708 skip_serializing_if = "Option::is_none"
3709 )]
3710 pub handler_name: Option<String>,
3711}
3712impl ServerExecutionDefinition {
3713 pub fn new() -> Self {
3714 Self::default()
3715 }
3716}
3717#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3718pub struct ServerTaskRequestMessage {
3719 #[serde(flatten)]
3720 pub job_request_message: JobRequestMessage,
3721 #[serde(
3722 rename = "taskDefinition",
3723 default,
3724 skip_serializing_if = "Option::is_none"
3725 )]
3726 pub task_definition: Option<TaskDefinition>,
3727 #[serde(
3728 rename = "taskInstance",
3729 default,
3730 skip_serializing_if = "Option::is_none"
3731 )]
3732 pub task_instance: Option<TaskInstance>,
3733}
3734impl ServerTaskRequestMessage {
3735 pub fn new() -> Self {
3736 Self::default()
3737 }
3738}
3739#[doc = "Represents an endpoint which may be used by an orchestration job."]
3740#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3741pub struct ServiceEndpoint {
3742 #[serde(
3743 rename = "administratorsGroup",
3744 default,
3745 skip_serializing_if = "Option::is_none"
3746 )]
3747 pub administrators_group: Option<IdentityRef>,
3748 #[serde(default, skip_serializing_if = "Option::is_none")]
3749 pub authorization: Option<EndpointAuthorization>,
3750 #[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
3751 pub created_by: Option<IdentityRef>,
3752 #[serde(default, skip_serializing_if = "Option::is_none")]
3753 pub data: Option<serde_json::Value>,
3754 #[doc = "Gets or sets the description of endpoint."]
3755 #[serde(default, skip_serializing_if = "Option::is_none")]
3756 pub description: Option<String>,
3757 #[serde(
3758 rename = "groupScopeId",
3759 default,
3760 skip_serializing_if = "Option::is_none"
3761 )]
3762 pub group_scope_id: Option<String>,
3763 #[doc = "Gets or sets the identifier of this endpoint."]
3764 #[serde(default, skip_serializing_if = "Option::is_none")]
3765 pub id: Option<String>,
3766 #[doc = "EndPoint state indicator"]
3767 #[serde(rename = "isReady", default, skip_serializing_if = "Option::is_none")]
3768 pub is_ready: Option<bool>,
3769 #[doc = "Indicates whether service endpoint is shared with other projects or not."]
3770 #[serde(rename = "isShared", default, skip_serializing_if = "Option::is_none")]
3771 pub is_shared: Option<bool>,
3772 #[doc = "Gets or sets the friendly name of the endpoint."]
3773 #[serde(default, skip_serializing_if = "Option::is_none")]
3774 pub name: Option<String>,
3775 #[doc = "Error message during creation/deletion of endpoint"]
3776 #[serde(
3777 rename = "operationStatus",
3778 default,
3779 skip_serializing_if = "Option::is_none"
3780 )]
3781 pub operation_status: Option<serde_json::Value>,
3782 #[doc = "Gets or sets the owner of the endpoint."]
3783 #[serde(default, skip_serializing_if = "Option::is_none")]
3784 pub owner: Option<String>,
3785 #[serde(
3786 rename = "readersGroup",
3787 default,
3788 skip_serializing_if = "Option::is_none"
3789 )]
3790 pub readers_group: Option<IdentityRef>,
3791 #[doc = "Gets or sets the type of the endpoint."]
3792 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
3793 pub type_: Option<String>,
3794 #[doc = "Gets or sets the url of the endpoint."]
3795 #[serde(default, skip_serializing_if = "Option::is_none")]
3796 pub url: Option<String>,
3797}
3798impl ServiceEndpoint {
3799 pub fn new() -> Self {
3800 Self::default()
3801 }
3802}
3803#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3804pub struct ServiceEndpointAuthenticationScheme {
3805 #[doc = "Gets or sets the authorization headers of service endpoint authentication scheme."]
3806 #[serde(
3807 rename = "authorizationHeaders",
3808 default,
3809 deserialize_with = "crate::serde::deserialize_null_as_default",
3810 skip_serializing_if = "Vec::is_empty"
3811 )]
3812 pub authorization_headers: Vec<AuthorizationHeader>,
3813 #[doc = "Gets or sets the certificates of service endpoint authentication scheme."]
3814 #[serde(
3815 rename = "clientCertificates",
3816 default,
3817 deserialize_with = "crate::serde::deserialize_null_as_default",
3818 skip_serializing_if = "Vec::is_empty"
3819 )]
3820 pub client_certificates: Vec<ClientCertificate>,
3821 #[doc = "Gets or sets the display name for the service endpoint authentication scheme."]
3822 #[serde(
3823 rename = "displayName",
3824 default,
3825 skip_serializing_if = "Option::is_none"
3826 )]
3827 pub display_name: Option<String>,
3828 #[doc = "Gets or sets the input descriptors for the service endpoint authentication scheme."]
3829 #[serde(
3830 rename = "inputDescriptors",
3831 default,
3832 deserialize_with = "crate::serde::deserialize_null_as_default",
3833 skip_serializing_if = "Vec::is_empty"
3834 )]
3835 pub input_descriptors: Vec<InputDescriptor>,
3836 #[doc = "Gets or sets the scheme for service endpoint authentication."]
3837 #[serde(default, skip_serializing_if = "Option::is_none")]
3838 pub scheme: Option<String>,
3839}
3840impl ServiceEndpointAuthenticationScheme {
3841 pub fn new() -> Self {
3842 Self::default()
3843 }
3844}
3845#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3846pub struct ServiceEndpointDetails {
3847 #[serde(default, skip_serializing_if = "Option::is_none")]
3848 pub authorization: Option<EndpointAuthorization>,
3849 #[serde(default, skip_serializing_if = "Option::is_none")]
3850 pub data: Option<serde_json::Value>,
3851 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
3852 pub type_: Option<String>,
3853 #[serde(default, skip_serializing_if = "Option::is_none")]
3854 pub url: Option<String>,
3855}
3856impl ServiceEndpointDetails {
3857 pub fn new() -> Self {
3858 Self::default()
3859 }
3860}
3861#[doc = "Represents service endpoint execution data."]
3862#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3863pub struct ServiceEndpointExecutionData {
3864 #[serde(default, skip_serializing_if = "Option::is_none")]
3865 pub definition: Option<TaskOrchestrationOwner>,
3866 #[doc = "Gets the finish time of service endpoint execution."]
3867 #[serde(
3868 rename = "finishTime",
3869 default,
3870 skip_serializing_if = "Option::is_none",
3871 with = "crate::date_time::rfc3339::option"
3872 )]
3873 pub finish_time: Option<time::OffsetDateTime>,
3874 #[doc = "Gets the Id of service endpoint execution data."]
3875 #[serde(default, skip_serializing_if = "Option::is_none")]
3876 pub id: Option<i64>,
3877 #[serde(default, skip_serializing_if = "Option::is_none")]
3878 pub owner: Option<TaskOrchestrationOwner>,
3879 #[doc = "Gets the plan type of service endpoint execution data."]
3880 #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
3881 pub plan_type: Option<String>,
3882 #[doc = "Gets the result of service endpoint execution."]
3883 #[serde(default, skip_serializing_if = "Option::is_none")]
3884 pub result: Option<service_endpoint_execution_data::Result>,
3885 #[doc = "Gets the start time of service endpoint execution."]
3886 #[serde(
3887 rename = "startTime",
3888 default,
3889 skip_serializing_if = "Option::is_none",
3890 with = "crate::date_time::rfc3339::option"
3891 )]
3892 pub start_time: Option<time::OffsetDateTime>,
3893}
3894impl ServiceEndpointExecutionData {
3895 pub fn new() -> Self {
3896 Self::default()
3897 }
3898}
3899pub mod service_endpoint_execution_data {
3900 use super::*;
3901 #[doc = "Gets the result of service endpoint execution."]
3902 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
3903 pub enum Result {
3904 #[serde(rename = "succeeded")]
3905 Succeeded,
3906 #[serde(rename = "succeededWithIssues")]
3907 SucceededWithIssues,
3908 #[serde(rename = "failed")]
3909 Failed,
3910 #[serde(rename = "canceled")]
3911 Canceled,
3912 #[serde(rename = "skipped")]
3913 Skipped,
3914 #[serde(rename = "abandoned")]
3915 Abandoned,
3916 }
3917}
3918#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3919pub struct ServiceEndpointExecutionRecord {
3920 #[doc = "Represents service endpoint execution data."]
3921 #[serde(default, skip_serializing_if = "Option::is_none")]
3922 pub data: Option<ServiceEndpointExecutionData>,
3923 #[doc = "Gets the Id of service endpoint."]
3924 #[serde(
3925 rename = "endpointId",
3926 default,
3927 skip_serializing_if = "Option::is_none"
3928 )]
3929 pub endpoint_id: Option<String>,
3930}
3931impl ServiceEndpointExecutionRecord {
3932 pub fn new() -> Self {
3933 Self::default()
3934 }
3935}
3936#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3937pub struct ServiceEndpointExecutionRecordsInput {
3938 #[doc = "Represents service endpoint execution data."]
3939 #[serde(default, skip_serializing_if = "Option::is_none")]
3940 pub data: Option<ServiceEndpointExecutionData>,
3941 #[serde(
3942 rename = "endpointIds",
3943 default,
3944 deserialize_with = "crate::serde::deserialize_null_as_default",
3945 skip_serializing_if = "Vec::is_empty"
3946 )]
3947 pub endpoint_ids: Vec<String>,
3948}
3949impl ServiceEndpointExecutionRecordsInput {
3950 pub fn new() -> Self {
3951 Self::default()
3952 }
3953}
3954#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3955pub struct ServiceEndpointRequest {
3956 #[serde(
3957 rename = "dataSourceDetails",
3958 default,
3959 skip_serializing_if = "Option::is_none"
3960 )]
3961 pub data_source_details: Option<DataSourceDetails>,
3962 #[serde(
3963 rename = "resultTransformationDetails",
3964 default,
3965 skip_serializing_if = "Option::is_none"
3966 )]
3967 pub result_transformation_details: Option<ResultTransformationDetails>,
3968 #[serde(
3969 rename = "serviceEndpointDetails",
3970 default,
3971 skip_serializing_if = "Option::is_none"
3972 )]
3973 pub service_endpoint_details: Option<ServiceEndpointDetails>,
3974}
3975impl ServiceEndpointRequest {
3976 pub fn new() -> Self {
3977 Self::default()
3978 }
3979}
3980#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
3981pub struct ServiceEndpointRequestResult {
3982 #[serde(
3983 rename = "errorMessage",
3984 default,
3985 skip_serializing_if = "Option::is_none"
3986 )]
3987 pub error_message: Option<String>,
3988 #[doc = "Represents an abstract JSON token."]
3989 #[serde(default, skip_serializing_if = "Option::is_none")]
3990 pub result: Option<JToken>,
3991 #[serde(
3992 rename = "statusCode",
3993 default,
3994 skip_serializing_if = "Option::is_none"
3995 )]
3996 pub status_code: Option<service_endpoint_request_result::StatusCode>,
3997}
3998impl ServiceEndpointRequestResult {
3999 pub fn new() -> Self {
4000 Self::default()
4001 }
4002}
4003pub mod service_endpoint_request_result {
4004 use super::*;
4005 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
4006 pub enum StatusCode {
4007 #[serde(rename = "continue")]
4008 Continue,
4009 #[serde(rename = "switchingProtocols")]
4010 SwitchingProtocols,
4011 #[serde(rename = "ok")]
4012 Ok,
4013 #[serde(rename = "created")]
4014 Created,
4015 #[serde(rename = "accepted")]
4016 Accepted,
4017 #[serde(rename = "nonAuthoritativeInformation")]
4018 NonAuthoritativeInformation,
4019 #[serde(rename = "noContent")]
4020 NoContent,
4021 #[serde(rename = "resetContent")]
4022 ResetContent,
4023 #[serde(rename = "partialContent")]
4024 PartialContent,
4025 #[serde(rename = "multipleChoices")]
4026 MultipleChoices,
4027 #[serde(rename = "ambiguous")]
4028 Ambiguous,
4029 #[serde(rename = "movedPermanently")]
4030 MovedPermanently,
4031 #[serde(rename = "moved")]
4032 Moved,
4033 #[serde(rename = "found")]
4034 Found,
4035 #[serde(rename = "redirect")]
4036 Redirect,
4037 #[serde(rename = "seeOther")]
4038 SeeOther,
4039 #[serde(rename = "redirectMethod")]
4040 RedirectMethod,
4041 #[serde(rename = "notModified")]
4042 NotModified,
4043 #[serde(rename = "useProxy")]
4044 UseProxy,
4045 #[serde(rename = "unused")]
4046 Unused,
4047 #[serde(rename = "temporaryRedirect")]
4048 TemporaryRedirect,
4049 #[serde(rename = "redirectKeepVerb")]
4050 RedirectKeepVerb,
4051 #[serde(rename = "badRequest")]
4052 BadRequest,
4053 #[serde(rename = "unauthorized")]
4054 Unauthorized,
4055 #[serde(rename = "paymentRequired")]
4056 PaymentRequired,
4057 #[serde(rename = "forbidden")]
4058 Forbidden,
4059 #[serde(rename = "notFound")]
4060 NotFound,
4061 #[serde(rename = "methodNotAllowed")]
4062 MethodNotAllowed,
4063 #[serde(rename = "notAcceptable")]
4064 NotAcceptable,
4065 #[serde(rename = "proxyAuthenticationRequired")]
4066 ProxyAuthenticationRequired,
4067 #[serde(rename = "requestTimeout")]
4068 RequestTimeout,
4069 #[serde(rename = "conflict")]
4070 Conflict,
4071 #[serde(rename = "gone")]
4072 Gone,
4073 #[serde(rename = "lengthRequired")]
4074 LengthRequired,
4075 #[serde(rename = "preconditionFailed")]
4076 PreconditionFailed,
4077 #[serde(rename = "requestEntityTooLarge")]
4078 RequestEntityTooLarge,
4079 #[serde(rename = "requestUriTooLong")]
4080 RequestUriTooLong,
4081 #[serde(rename = "unsupportedMediaType")]
4082 UnsupportedMediaType,
4083 #[serde(rename = "requestedRangeNotSatisfiable")]
4084 RequestedRangeNotSatisfiable,
4085 #[serde(rename = "expectationFailed")]
4086 ExpectationFailed,
4087 #[serde(rename = "upgradeRequired")]
4088 UpgradeRequired,
4089 #[serde(rename = "internalServerError")]
4090 InternalServerError,
4091 #[serde(rename = "notImplemented")]
4092 NotImplemented,
4093 #[serde(rename = "badGateway")]
4094 BadGateway,
4095 #[serde(rename = "serviceUnavailable")]
4096 ServiceUnavailable,
4097 #[serde(rename = "gatewayTimeout")]
4098 GatewayTimeout,
4099 #[serde(rename = "httpVersionNotSupported")]
4100 HttpVersionNotSupported,
4101 }
4102}
4103#[doc = "Represents type of the service endpoint."]
4104#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4105pub struct ServiceEndpointType {
4106 #[doc = "Authentication scheme of service endpoint type."]
4107 #[serde(
4108 rename = "authenticationSchemes",
4109 default,
4110 deserialize_with = "crate::serde::deserialize_null_as_default",
4111 skip_serializing_if = "Vec::is_empty"
4112 )]
4113 pub authentication_schemes: Vec<ServiceEndpointAuthenticationScheme>,
4114 #[doc = "Data sources of service endpoint type."]
4115 #[serde(
4116 rename = "dataSources",
4117 default,
4118 deserialize_with = "crate::serde::deserialize_null_as_default",
4119 skip_serializing_if = "Vec::is_empty"
4120 )]
4121 pub data_sources: Vec<DataSource>,
4122 #[doc = "Dependency data of service endpoint type."]
4123 #[serde(
4124 rename = "dependencyData",
4125 default,
4126 deserialize_with = "crate::serde::deserialize_null_as_default",
4127 skip_serializing_if = "Vec::is_empty"
4128 )]
4129 pub dependency_data: Vec<DependencyData>,
4130 #[doc = "Gets or sets the description of service endpoint type."]
4131 #[serde(default, skip_serializing_if = "Option::is_none")]
4132 pub description: Option<String>,
4133 #[doc = "Gets or sets the display name of service endpoint type."]
4134 #[serde(
4135 rename = "displayName",
4136 default,
4137 skip_serializing_if = "Option::is_none"
4138 )]
4139 pub display_name: Option<String>,
4140 #[doc = "Represents url of the service endpoint."]
4141 #[serde(
4142 rename = "endpointUrl",
4143 default,
4144 skip_serializing_if = "Option::is_none"
4145 )]
4146 pub endpoint_url: Option<EndpointUrl>,
4147 #[serde(rename = "helpLink", default, skip_serializing_if = "Option::is_none")]
4148 pub help_link: Option<HelpLink>,
4149 #[serde(
4150 rename = "helpMarkDown",
4151 default,
4152 skip_serializing_if = "Option::is_none"
4153 )]
4154 pub help_mark_down: Option<String>,
4155 #[doc = "Gets or sets the icon url of service endpoint type."]
4156 #[serde(rename = "iconUrl", default, skip_serializing_if = "Option::is_none")]
4157 pub icon_url: Option<String>,
4158 #[doc = "Input descriptor of service endpoint type."]
4159 #[serde(
4160 rename = "inputDescriptors",
4161 default,
4162 deserialize_with = "crate::serde::deserialize_null_as_default",
4163 skip_serializing_if = "Vec::is_empty"
4164 )]
4165 pub input_descriptors: Vec<InputDescriptor>,
4166 #[doc = "Gets or sets the name of service endpoint type."]
4167 #[serde(default, skip_serializing_if = "Option::is_none")]
4168 pub name: Option<String>,
4169 #[doc = "Trusted hosts of a service endpoint type."]
4170 #[serde(
4171 rename = "trustedHosts",
4172 default,
4173 deserialize_with = "crate::serde::deserialize_null_as_default",
4174 skip_serializing_if = "Vec::is_empty"
4175 )]
4176 pub trusted_hosts: Vec<String>,
4177 #[doc = "Gets or sets the ui contribution id of service endpoint type."]
4178 #[serde(
4179 rename = "uiContributionId",
4180 default,
4181 skip_serializing_if = "Option::is_none"
4182 )]
4183 pub ui_contribution_id: Option<String>,
4184}
4185impl ServiceEndpointType {
4186 pub fn new() -> Self {
4187 Self::default()
4188 }
4189}
4190#[doc = "A task agent."]
4191#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4192pub struct TaskAgent {
4193 #[serde(flatten)]
4194 pub task_agent_reference: TaskAgentReference,
4195 #[serde(
4196 rename = "assignedAgentCloudRequest",
4197 default,
4198 skip_serializing_if = "Option::is_none"
4199 )]
4200 pub assigned_agent_cloud_request: Option<TaskAgentCloudRequest>,
4201 #[doc = "A job request for an agent."]
4202 #[serde(
4203 rename = "assignedRequest",
4204 default,
4205 skip_serializing_if = "Option::is_none"
4206 )]
4207 pub assigned_request: Option<TaskAgentJobRequest>,
4208 #[doc = "Provides data necessary for authorizing the agent using OAuth 2.0 authentication flows."]
4209 #[serde(default, skip_serializing_if = "Option::is_none")]
4210 pub authorization: Option<TaskAgentAuthorization>,
4211 #[doc = "Date on which this agent was created."]
4212 #[serde(
4213 rename = "createdOn",
4214 default,
4215 skip_serializing_if = "Option::is_none",
4216 with = "crate::date_time::rfc3339::option"
4217 )]
4218 pub created_on: Option<time::OffsetDateTime>,
4219 #[doc = "A job request for an agent."]
4220 #[serde(
4221 rename = "lastCompletedRequest",
4222 default,
4223 skip_serializing_if = "Option::is_none"
4224 )]
4225 pub last_completed_request: Option<TaskAgentJobRequest>,
4226 #[doc = "Maximum job parallelism allowed for this agent."]
4227 #[serde(
4228 rename = "maxParallelism",
4229 default,
4230 skip_serializing_if = "Option::is_none"
4231 )]
4232 pub max_parallelism: Option<i32>,
4233 #[doc = "Details about an agent update."]
4234 #[serde(
4235 rename = "pendingUpdate",
4236 default,
4237 skip_serializing_if = "Option::is_none"
4238 )]
4239 pub pending_update: Option<TaskAgentUpdate>,
4240 #[doc = "The class represents a property bag as a collection of key-value pairs. Values of all primitive types (any type with a `TypeCode != TypeCode.Object`) except for `DBNull` are accepted. Values of type Byte[], Int32, Double, DateType and String preserve their type, other primitives are retuned as a String. Byte[] expected as base64 encoded string."]
4241 #[serde(default, skip_serializing_if = "Option::is_none")]
4242 pub properties: Option<PropertiesCollection>,
4243 #[doc = "Date on which the last connectivity status change occurred."]
4244 #[serde(
4245 rename = "statusChangedOn",
4246 default,
4247 skip_serializing_if = "Option::is_none",
4248 with = "crate::date_time::rfc3339::option"
4249 )]
4250 pub status_changed_on: Option<time::OffsetDateTime>,
4251 #[doc = "System-defined capabilities supported by this agent's host. Warning: To set capabilities use the PUT method, PUT will completely overwrite existing capabilities."]
4252 #[serde(
4253 rename = "systemCapabilities",
4254 default,
4255 skip_serializing_if = "Option::is_none"
4256 )]
4257 pub system_capabilities: Option<serde_json::Value>,
4258 #[doc = "User-defined capabilities supported by this agent's host. Warning: To set capabilities use the PUT method, PUT will completely overwrite existing capabilities."]
4259 #[serde(
4260 rename = "userCapabilities",
4261 default,
4262 skip_serializing_if = "Option::is_none"
4263 )]
4264 pub user_capabilities: Option<serde_json::Value>,
4265}
4266impl TaskAgent {
4267 pub fn new() -> Self {
4268 Self::default()
4269 }
4270}
4271#[doc = "Provides data necessary for authorizing the agent using OAuth 2.0 authentication flows."]
4272#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4273pub struct TaskAgentAuthorization {
4274 #[doc = "Endpoint used to obtain access tokens from the configured token service."]
4275 #[serde(
4276 rename = "authorizationUrl",
4277 default,
4278 skip_serializing_if = "Option::is_none"
4279 )]
4280 pub authorization_url: Option<String>,
4281 #[doc = "Client identifier for this agent."]
4282 #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
4283 pub client_id: Option<String>,
4284 #[doc = "Represents the public key portion of an RSA asymmetric key."]
4285 #[serde(rename = "publicKey", default, skip_serializing_if = "Option::is_none")]
4286 pub public_key: Option<TaskAgentPublicKey>,
4287}
4288impl TaskAgentAuthorization {
4289 pub fn new() -> Self {
4290 Self::default()
4291 }
4292}
4293#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4294pub struct TaskAgentCloud {
4295 #[doc = "Gets or sets a AcquireAgentEndpoint using which a request can be made to acquire new agent"]
4296 #[serde(
4297 rename = "acquireAgentEndpoint",
4298 default,
4299 skip_serializing_if = "Option::is_none"
4300 )]
4301 pub acquire_agent_endpoint: Option<String>,
4302 #[serde(
4303 rename = "acquisitionTimeout",
4304 default,
4305 skip_serializing_if = "Option::is_none"
4306 )]
4307 pub acquisition_timeout: Option<i32>,
4308 #[serde(
4309 rename = "agentCloudId",
4310 default,
4311 skip_serializing_if = "Option::is_none"
4312 )]
4313 pub agent_cloud_id: Option<i32>,
4314 #[serde(
4315 rename = "getAccountParallelismEndpoint",
4316 default,
4317 skip_serializing_if = "Option::is_none"
4318 )]
4319 pub get_account_parallelism_endpoint: Option<String>,
4320 #[serde(
4321 rename = "getAgentDefinitionEndpoint",
4322 default,
4323 skip_serializing_if = "Option::is_none"
4324 )]
4325 pub get_agent_definition_endpoint: Option<String>,
4326 #[serde(
4327 rename = "getAgentRequestStatusEndpoint",
4328 default,
4329 skip_serializing_if = "Option::is_none"
4330 )]
4331 pub get_agent_request_status_endpoint: Option<String>,
4332 #[serde(default, skip_serializing_if = "Option::is_none")]
4333 pub id: Option<String>,
4334 #[doc = "Signifies that this Agent Cloud is internal and should not be user-manageable"]
4335 #[serde(default, skip_serializing_if = "Option::is_none")]
4336 pub internal: Option<bool>,
4337 #[serde(
4338 rename = "maxParallelism",
4339 default,
4340 skip_serializing_if = "Option::is_none"
4341 )]
4342 pub max_parallelism: Option<i32>,
4343 #[serde(default, skip_serializing_if = "Option::is_none")]
4344 pub name: Option<String>,
4345 #[serde(
4346 rename = "releaseAgentEndpoint",
4347 default,
4348 skip_serializing_if = "Option::is_none"
4349 )]
4350 pub release_agent_endpoint: Option<String>,
4351 #[serde(
4352 rename = "sharedSecret",
4353 default,
4354 skip_serializing_if = "Option::is_none"
4355 )]
4356 pub shared_secret: Option<String>,
4357 #[doc = "Gets or sets the type of the endpoint."]
4358 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
4359 pub type_: Option<String>,
4360}
4361impl TaskAgentCloud {
4362 pub fn new() -> Self {
4363 Self::default()
4364 }
4365}
4366#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4367pub struct TaskAgentCloudList {
4368 #[serde(default, skip_serializing_if = "Option::is_none")]
4369 pub count: Option<i32>,
4370 #[serde(
4371 default,
4372 deserialize_with = "crate::serde::deserialize_null_as_default",
4373 skip_serializing_if = "Vec::is_empty"
4374 )]
4375 pub value: Vec<TaskAgentCloud>,
4376}
4377impl TaskAgentCloudList {
4378 pub fn new() -> Self {
4379 Self::default()
4380 }
4381}
4382#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4383pub struct TaskAgentCloudRequest {
4384 #[doc = "A reference to an agent."]
4385 #[serde(default, skip_serializing_if = "Option::is_none")]
4386 pub agent: Option<TaskAgentReference>,
4387 #[serde(
4388 rename = "agentCloudId",
4389 default,
4390 skip_serializing_if = "Option::is_none"
4391 )]
4392 pub agent_cloud_id: Option<i32>,
4393 #[serde(
4394 rename = "agentConnectedTime",
4395 default,
4396 skip_serializing_if = "Option::is_none",
4397 with = "crate::date_time::rfc3339::option"
4398 )]
4399 pub agent_connected_time: Option<time::OffsetDateTime>,
4400 #[serde(rename = "agentData", default, skip_serializing_if = "Option::is_none")]
4401 pub agent_data: Option<serde_json::Value>,
4402 #[serde(
4403 rename = "agentSpecification",
4404 default,
4405 skip_serializing_if = "Option::is_none"
4406 )]
4407 pub agent_specification: Option<serde_json::Value>,
4408 #[serde(default, skip_serializing_if = "Option::is_none")]
4409 pub pool: Option<TaskAgentPoolReference>,
4410 #[serde(
4411 rename = "provisionedTime",
4412 default,
4413 skip_serializing_if = "Option::is_none",
4414 with = "crate::date_time::rfc3339::option"
4415 )]
4416 pub provisioned_time: Option<time::OffsetDateTime>,
4417 #[serde(
4418 rename = "provisionRequestTime",
4419 default,
4420 skip_serializing_if = "Option::is_none",
4421 with = "crate::date_time::rfc3339::option"
4422 )]
4423 pub provision_request_time: Option<time::OffsetDateTime>,
4424 #[serde(
4425 rename = "releaseRequestTime",
4426 default,
4427 skip_serializing_if = "Option::is_none",
4428 with = "crate::date_time::rfc3339::option"
4429 )]
4430 pub release_request_time: Option<time::OffsetDateTime>,
4431 #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
4432 pub request_id: Option<String>,
4433}
4434impl TaskAgentCloudRequest {
4435 pub fn new() -> Self {
4436 Self::default()
4437 }
4438}
4439#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4440pub struct TaskAgentCloudRequestList {
4441 #[serde(default, skip_serializing_if = "Option::is_none")]
4442 pub count: Option<i32>,
4443 #[serde(
4444 default,
4445 deserialize_with = "crate::serde::deserialize_null_as_default",
4446 skip_serializing_if = "Vec::is_empty"
4447 )]
4448 pub value: Vec<TaskAgentCloudRequest>,
4449}
4450impl TaskAgentCloudRequestList {
4451 pub fn new() -> Self {
4452 Self::default()
4453 }
4454}
4455#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4456pub struct TaskAgentCloudType {
4457 #[doc = "Gets or sets the display name of agent cloud type."]
4458 #[serde(
4459 rename = "displayName",
4460 default,
4461 skip_serializing_if = "Option::is_none"
4462 )]
4463 pub display_name: Option<String>,
4464 #[doc = "Gets or sets the input descriptors"]
4465 #[serde(
4466 rename = "inputDescriptors",
4467 default,
4468 deserialize_with = "crate::serde::deserialize_null_as_default",
4469 skip_serializing_if = "Vec::is_empty"
4470 )]
4471 pub input_descriptors: Vec<InputDescriptor>,
4472 #[doc = "Gets or sets the name of agent cloud type."]
4473 #[serde(default, skip_serializing_if = "Option::is_none")]
4474 pub name: Option<String>,
4475}
4476impl TaskAgentCloudType {
4477 pub fn new() -> Self {
4478 Self::default()
4479 }
4480}
4481#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4482pub struct TaskAgentCloudTypeList {
4483 #[serde(default, skip_serializing_if = "Option::is_none")]
4484 pub count: Option<i32>,
4485 #[serde(
4486 default,
4487 deserialize_with = "crate::serde::deserialize_null_as_default",
4488 skip_serializing_if = "Vec::is_empty"
4489 )]
4490 pub value: Vec<TaskAgentCloudType>,
4491}
4492impl TaskAgentCloudTypeList {
4493 pub fn new() -> Self {
4494 Self::default()
4495 }
4496}
4497#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4498pub struct TaskAgentDowngrade {
4499 #[serde(flatten)]
4500 pub task_agent_update_reason: TaskAgentUpdateReason,
4501}
4502impl TaskAgentDowngrade {
4503 pub fn new() -> Self {
4504 Self::default()
4505 }
4506}
4507#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4508pub struct TaskAgentJob {
4509 #[serde(default, skip_serializing_if = "Option::is_none")]
4510 pub container: Option<String>,
4511 #[serde(default, skip_serializing_if = "Option::is_none")]
4512 pub id: Option<String>,
4513 #[serde(default, skip_serializing_if = "Option::is_none")]
4514 pub name: Option<String>,
4515 #[serde(
4516 rename = "sidecarContainers",
4517 default,
4518 skip_serializing_if = "Option::is_none"
4519 )]
4520 pub sidecar_containers: Option<serde_json::Value>,
4521 #[serde(
4522 default,
4523 deserialize_with = "crate::serde::deserialize_null_as_default",
4524 skip_serializing_if = "Vec::is_empty"
4525 )]
4526 pub steps: Vec<TaskAgentJobStep>,
4527 #[serde(
4528 default,
4529 deserialize_with = "crate::serde::deserialize_null_as_default",
4530 skip_serializing_if = "Vec::is_empty"
4531 )]
4532 pub variables: Vec<TaskAgentJobVariable>,
4533}
4534impl TaskAgentJob {
4535 pub fn new() -> Self {
4536 Self::default()
4537 }
4538}
4539#[doc = "A job request for an agent."]
4540#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4541pub struct TaskAgentJobRequest {
4542 #[serde(
4543 rename = "agentSpecification",
4544 default,
4545 skip_serializing_if = "Option::is_none"
4546 )]
4547 pub agent_specification: Option<serde_json::Value>,
4548 #[doc = "The date/time this request was assigned."]
4549 #[serde(
4550 rename = "assignTime",
4551 default,
4552 skip_serializing_if = "Option::is_none",
4553 with = "crate::date_time::rfc3339::option"
4554 )]
4555 pub assign_time: Option<time::OffsetDateTime>,
4556 #[doc = "Additional data about the request."]
4557 #[serde(default, skip_serializing_if = "Option::is_none")]
4558 pub data: Option<serde_json::Value>,
4559 #[serde(default, skip_serializing_if = "Option::is_none")]
4560 pub definition: Option<TaskOrchestrationOwner>,
4561 #[doc = "A list of demands required to fulfill this request."]
4562 #[serde(
4563 default,
4564 deserialize_with = "crate::serde::deserialize_null_as_default",
4565 skip_serializing_if = "Vec::is_empty"
4566 )]
4567 pub demands: Vec<Demand>,
4568 #[doc = "The date/time this request was finished."]
4569 #[serde(
4570 rename = "finishTime",
4571 default,
4572 skip_serializing_if = "Option::is_none",
4573 with = "crate::date_time::rfc3339::option"
4574 )]
4575 pub finish_time: Option<time::OffsetDateTime>,
4576 #[doc = "The host which triggered this request."]
4577 #[serde(rename = "hostId", default, skip_serializing_if = "Option::is_none")]
4578 pub host_id: Option<String>,
4579 #[doc = "ID of the job resulting from this request."]
4580 #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
4581 pub job_id: Option<String>,
4582 #[doc = "Name of the job resulting from this request."]
4583 #[serde(rename = "jobName", default, skip_serializing_if = "Option::is_none")]
4584 pub job_name: Option<String>,
4585 #[doc = "The deadline for the agent to renew the lock."]
4586 #[serde(
4587 rename = "lockedUntil",
4588 default,
4589 skip_serializing_if = "Option::is_none",
4590 with = "crate::date_time::rfc3339::option"
4591 )]
4592 pub locked_until: Option<time::OffsetDateTime>,
4593 #[serde(
4594 rename = "matchedAgents",
4595 default,
4596 deserialize_with = "crate::serde::deserialize_null_as_default",
4597 skip_serializing_if = "Vec::is_empty"
4598 )]
4599 pub matched_agents: Vec<TaskAgentReference>,
4600 #[serde(
4601 rename = "matchesAllAgentsInPool",
4602 default,
4603 skip_serializing_if = "Option::is_none"
4604 )]
4605 pub matches_all_agents_in_pool: Option<bool>,
4606 #[serde(
4607 rename = "orchestrationId",
4608 default,
4609 skip_serializing_if = "Option::is_none"
4610 )]
4611 pub orchestration_id: Option<String>,
4612 #[serde(default, skip_serializing_if = "Option::is_none")]
4613 pub owner: Option<TaskOrchestrationOwner>,
4614 #[serde(rename = "planGroup", default, skip_serializing_if = "Option::is_none")]
4615 pub plan_group: Option<String>,
4616 #[doc = "Internal ID for the orchestration plan connected with this request."]
4617 #[serde(rename = "planId", default, skip_serializing_if = "Option::is_none")]
4618 pub plan_id: Option<String>,
4619 #[doc = "Internal detail representing the type of orchestration plan."]
4620 #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
4621 pub plan_type: Option<String>,
4622 #[doc = "The ID of the pool this request targets"]
4623 #[serde(rename = "poolId", default, skip_serializing_if = "Option::is_none")]
4624 pub pool_id: Option<i32>,
4625 #[serde(default, skip_serializing_if = "Option::is_none")]
4626 pub priority: Option<i32>,
4627 #[doc = "The ID of the queue this request targets"]
4628 #[serde(rename = "queueId", default, skip_serializing_if = "Option::is_none")]
4629 pub queue_id: Option<i32>,
4630 #[doc = "The date/time this request was queued."]
4631 #[serde(
4632 rename = "queueTime",
4633 default,
4634 skip_serializing_if = "Option::is_none",
4635 with = "crate::date_time::rfc3339::option"
4636 )]
4637 pub queue_time: Option<time::OffsetDateTime>,
4638 #[doc = "The date/time this request was receieved by an agent."]
4639 #[serde(
4640 rename = "receiveTime",
4641 default,
4642 skip_serializing_if = "Option::is_none",
4643 with = "crate::date_time::rfc3339::option"
4644 )]
4645 pub receive_time: Option<time::OffsetDateTime>,
4646 #[doc = "ID of the request."]
4647 #[serde(rename = "requestId", default, skip_serializing_if = "Option::is_none")]
4648 pub request_id: Option<i64>,
4649 #[doc = "A reference to an agent."]
4650 #[serde(
4651 rename = "reservedAgent",
4652 default,
4653 skip_serializing_if = "Option::is_none"
4654 )]
4655 pub reserved_agent: Option<TaskAgentReference>,
4656 #[doc = "The result of this request."]
4657 #[serde(default, skip_serializing_if = "Option::is_none")]
4658 pub result: Option<task_agent_job_request::Result>,
4659 #[doc = "Scope of the pipeline; matches the project ID."]
4660 #[serde(rename = "scopeId", default, skip_serializing_if = "Option::is_none")]
4661 pub scope_id: Option<String>,
4662 #[doc = "The service which owns this request."]
4663 #[serde(
4664 rename = "serviceOwner",
4665 default,
4666 skip_serializing_if = "Option::is_none"
4667 )]
4668 pub service_owner: Option<String>,
4669 #[serde(
4670 rename = "statusMessage",
4671 default,
4672 skip_serializing_if = "Option::is_none"
4673 )]
4674 pub status_message: Option<String>,
4675 #[serde(
4676 rename = "userDelayed",
4677 default,
4678 skip_serializing_if = "Option::is_none"
4679 )]
4680 pub user_delayed: Option<bool>,
4681}
4682impl TaskAgentJobRequest {
4683 pub fn new() -> Self {
4684 Self::default()
4685 }
4686}
4687pub mod task_agent_job_request {
4688 use super::*;
4689 #[doc = "The result of this request."]
4690 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
4691 pub enum Result {
4692 #[serde(rename = "succeeded")]
4693 Succeeded,
4694 #[serde(rename = "succeededWithIssues")]
4695 SucceededWithIssues,
4696 #[serde(rename = "failed")]
4697 Failed,
4698 #[serde(rename = "canceled")]
4699 Canceled,
4700 #[serde(rename = "skipped")]
4701 Skipped,
4702 #[serde(rename = "abandoned")]
4703 Abandoned,
4704 }
4705}
4706#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4707pub struct TaskAgentJobStep {
4708 #[serde(default, skip_serializing_if = "Option::is_none")]
4709 pub condition: Option<String>,
4710 #[serde(
4711 rename = "continueOnError",
4712 default,
4713 skip_serializing_if = "Option::is_none"
4714 )]
4715 pub continue_on_error: Option<bool>,
4716 #[serde(default, skip_serializing_if = "Option::is_none")]
4717 pub enabled: Option<bool>,
4718 #[serde(default, skip_serializing_if = "Option::is_none")]
4719 pub env: Option<serde_json::Value>,
4720 #[serde(default, skip_serializing_if = "Option::is_none")]
4721 pub id: Option<String>,
4722 #[serde(default, skip_serializing_if = "Option::is_none")]
4723 pub inputs: Option<serde_json::Value>,
4724 #[serde(default, skip_serializing_if = "Option::is_none")]
4725 pub name: Option<String>,
4726 #[serde(
4727 rename = "retryCountOnTaskFailure",
4728 default,
4729 skip_serializing_if = "Option::is_none"
4730 )]
4731 pub retry_count_on_task_failure: Option<i32>,
4732 #[serde(default, skip_serializing_if = "Option::is_none")]
4733 pub task: Option<TaskAgentJobTask>,
4734 #[serde(
4735 rename = "timeoutInMinutes",
4736 default,
4737 skip_serializing_if = "Option::is_none"
4738 )]
4739 pub timeout_in_minutes: Option<i32>,
4740 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
4741 pub type_: Option<task_agent_job_step::Type>,
4742}
4743impl TaskAgentJobStep {
4744 pub fn new() -> Self {
4745 Self::default()
4746 }
4747}
4748pub mod task_agent_job_step {
4749 use super::*;
4750 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
4751 pub enum Type {
4752 #[serde(rename = "task")]
4753 Task,
4754 #[serde(rename = "action")]
4755 Action,
4756 }
4757}
4758#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4759pub struct TaskAgentJobTask {
4760 #[serde(default, skip_serializing_if = "Option::is_none")]
4761 pub id: Option<String>,
4762 #[serde(default, skip_serializing_if = "Option::is_none")]
4763 pub name: Option<String>,
4764 #[serde(default, skip_serializing_if = "Option::is_none")]
4765 pub version: Option<String>,
4766}
4767impl TaskAgentJobTask {
4768 pub fn new() -> Self {
4769 Self::default()
4770 }
4771}
4772#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4773pub struct TaskAgentJobVariable {
4774 #[serde(default, skip_serializing_if = "Option::is_none")]
4775 pub name: Option<String>,
4776 #[serde(default, skip_serializing_if = "Option::is_none")]
4777 pub secret: Option<bool>,
4778 #[serde(default, skip_serializing_if = "Option::is_none")]
4779 pub value: Option<String>,
4780}
4781impl TaskAgentJobVariable {
4782 pub fn new() -> Self {
4783 Self::default()
4784 }
4785}
4786#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4787pub struct TaskAgentList {
4788 #[serde(default, skip_serializing_if = "Option::is_none")]
4789 pub count: Option<i32>,
4790 #[serde(
4791 default,
4792 deserialize_with = "crate::serde::deserialize_null_as_default",
4793 skip_serializing_if = "Vec::is_empty"
4794 )]
4795 pub value: Vec<TaskAgent>,
4796}
4797impl TaskAgentList {
4798 pub fn new() -> Self {
4799 Self::default()
4800 }
4801}
4802#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4803pub struct TaskAgentManualUpdate {
4804 #[serde(flatten)]
4805 pub task_agent_update_reason: TaskAgentUpdateReason,
4806}
4807impl TaskAgentManualUpdate {
4808 pub fn new() -> Self {
4809 Self::default()
4810 }
4811}
4812#[doc = "Provides a contract for receiving messages from the task orchestrator."]
4813#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4814pub struct TaskAgentMessage {
4815 #[doc = "Gets or sets the body of the message. If the <c>IV</c> property is provided the body will need to be decrypted using the <c>TaskAgentSession.EncryptionKey</c> value in addition to the <c>IV</c>."]
4816 #[serde(default, skip_serializing_if = "Option::is_none")]
4817 pub body: Option<String>,
4818 #[doc = "Gets or sets the initialization vector used to encrypt this message."]
4819 #[serde(
4820 default,
4821 deserialize_with = "crate::serde::deserialize_null_as_default",
4822 skip_serializing_if = "Vec::is_empty"
4823 )]
4824 pub iv: Vec<String>,
4825 #[doc = "Gets or sets the message identifier."]
4826 #[serde(rename = "messageId", default, skip_serializing_if = "Option::is_none")]
4827 pub message_id: Option<i64>,
4828 #[doc = "Gets or sets the message type, describing the data contract found in <c>TaskAgentMessage.Body</c>."]
4829 #[serde(
4830 rename = "messageType",
4831 default,
4832 skip_serializing_if = "Option::is_none"
4833 )]
4834 pub message_type: Option<String>,
4835}
4836impl TaskAgentMessage {
4837 pub fn new() -> Self {
4838 Self::default()
4839 }
4840}
4841#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4842pub struct TaskAgentMinAgentVersionRequiredUpdate {
4843 #[serde(flatten)]
4844 pub task_agent_update_reason: TaskAgentUpdateReason,
4845 #[serde(
4846 rename = "jobDefinition",
4847 default,
4848 skip_serializing_if = "Option::is_none"
4849 )]
4850 pub job_definition: Option<TaskOrchestrationOwner>,
4851 #[serde(rename = "jobOwner", default, skip_serializing_if = "Option::is_none")]
4852 pub job_owner: Option<TaskOrchestrationOwner>,
4853 #[serde(
4854 rename = "minAgentVersion",
4855 default,
4856 skip_serializing_if = "Option::is_none"
4857 )]
4858 pub min_agent_version: Option<Demand>,
4859}
4860impl TaskAgentMinAgentVersionRequiredUpdate {
4861 pub fn new() -> Self {
4862 Self::default()
4863 }
4864}
4865#[doc = "An organization-level grouping of agents."]
4866#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4867pub struct TaskAgentPool {
4868 #[serde(flatten)]
4869 pub task_agent_pool_reference: TaskAgentPoolReference,
4870 #[doc = "The ID of the associated agent cloud."]
4871 #[serde(
4872 rename = "agentCloudId",
4873 default,
4874 skip_serializing_if = "Option::is_none"
4875 )]
4876 pub agent_cloud_id: Option<i32>,
4877 #[doc = "Whether or not a queue should be automatically provisioned for each project collection."]
4878 #[serde(
4879 rename = "autoProvision",
4880 default,
4881 skip_serializing_if = "Option::is_none"
4882 )]
4883 pub auto_provision: Option<bool>,
4884 #[doc = "Whether or not the pool should autosize itself based on the Agent Cloud Provider settings."]
4885 #[serde(rename = "autoSize", default, skip_serializing_if = "Option::is_none")]
4886 pub auto_size: Option<bool>,
4887 #[doc = "Whether or not agents in this pool are allowed to automatically update"]
4888 #[serde(
4889 rename = "autoUpdate",
4890 default,
4891 skip_serializing_if = "Option::is_none"
4892 )]
4893 pub auto_update: Option<bool>,
4894 #[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
4895 pub created_by: Option<IdentityRef>,
4896 #[doc = "The date/time of the pool creation."]
4897 #[serde(
4898 rename = "createdOn",
4899 default,
4900 skip_serializing_if = "Option::is_none",
4901 with = "crate::date_time::rfc3339::option"
4902 )]
4903 pub created_on: Option<time::OffsetDateTime>,
4904 #[serde(default, skip_serializing_if = "Option::is_none")]
4905 pub owner: Option<IdentityRef>,
4906 #[doc = "The class represents a property bag as a collection of key-value pairs. Values of all primitive types (any type with a `TypeCode != TypeCode.Object`) except for `DBNull` are accepted. Values of type Byte[], Int32, Double, DateType and String preserve their type, other primitives are retuned as a String. Byte[] expected as base64 encoded string."]
4907 #[serde(default, skip_serializing_if = "Option::is_none")]
4908 pub properties: Option<PropertiesCollection>,
4909 #[doc = "Target parallelism - Only applies to agent pools that are backed by pool providers. It will be null for regular pools."]
4910 #[serde(
4911 rename = "targetSize",
4912 default,
4913 skip_serializing_if = "Option::is_none"
4914 )]
4915 pub target_size: Option<i32>,
4916}
4917impl TaskAgentPool {
4918 pub fn new() -> Self {
4919 Self::default()
4920 }
4921}
4922#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4923pub struct TaskAgentPoolList {
4924 #[serde(default, skip_serializing_if = "Option::is_none")]
4925 pub count: Option<i32>,
4926 #[serde(
4927 default,
4928 deserialize_with = "crate::serde::deserialize_null_as_default",
4929 skip_serializing_if = "Vec::is_empty"
4930 )]
4931 pub value: Vec<TaskAgentPool>,
4932}
4933impl TaskAgentPoolList {
4934 pub fn new() -> Self {
4935 Self::default()
4936 }
4937}
4938#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4939pub struct TaskAgentPoolMaintenanceDefinition {
4940 #[doc = "Enable maintenance"]
4941 #[serde(default, skip_serializing_if = "Option::is_none")]
4942 pub enabled: Option<bool>,
4943 #[doc = "Id"]
4944 #[serde(default, skip_serializing_if = "Option::is_none")]
4945 pub id: Option<i32>,
4946 #[doc = "Maintenance job timeout per agent"]
4947 #[serde(
4948 rename = "jobTimeoutInMinutes",
4949 default,
4950 skip_serializing_if = "Option::is_none"
4951 )]
4952 pub job_timeout_in_minutes: Option<i32>,
4953 #[doc = "Max percentage of agents within a pool running maintenance job at given time"]
4954 #[serde(
4955 rename = "maxConcurrentAgentsPercentage",
4956 default,
4957 skip_serializing_if = "Option::is_none"
4958 )]
4959 pub max_concurrent_agents_percentage: Option<i32>,
4960 #[serde(default, skip_serializing_if = "Option::is_none")]
4961 pub options: Option<TaskAgentPoolMaintenanceOptions>,
4962 #[serde(default, skip_serializing_if = "Option::is_none")]
4963 pub pool: Option<TaskAgentPoolReference>,
4964 #[serde(
4965 rename = "retentionPolicy",
4966 default,
4967 skip_serializing_if = "Option::is_none"
4968 )]
4969 pub retention_policy: Option<TaskAgentPoolMaintenanceRetentionPolicy>,
4970 #[serde(
4971 rename = "scheduleSetting",
4972 default,
4973 skip_serializing_if = "Option::is_none"
4974 )]
4975 pub schedule_setting: Option<TaskAgentPoolMaintenanceSchedule>,
4976}
4977impl TaskAgentPoolMaintenanceDefinition {
4978 pub fn new() -> Self {
4979 Self::default()
4980 }
4981}
4982#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
4983pub struct TaskAgentPoolMaintenanceJob {
4984 #[doc = "The maintenance definition for the maintenance job"]
4985 #[serde(
4986 rename = "definitionId",
4987 default,
4988 skip_serializing_if = "Option::is_none"
4989 )]
4990 pub definition_id: Option<i32>,
4991 #[doc = "The total error counts during the maintenance job"]
4992 #[serde(
4993 rename = "errorCount",
4994 default,
4995 skip_serializing_if = "Option::is_none"
4996 )]
4997 pub error_count: Option<i32>,
4998 #[doc = "Time that the maintenance job was completed"]
4999 #[serde(
5000 rename = "finishTime",
5001 default,
5002 skip_serializing_if = "Option::is_none",
5003 with = "crate::date_time::rfc3339::option"
5004 )]
5005 pub finish_time: Option<time::OffsetDateTime>,
5006 #[doc = "Id of the maintenance job"]
5007 #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
5008 pub job_id: Option<i32>,
5009 #[doc = "The log download url for the maintenance job"]
5010 #[serde(
5011 rename = "logsDownloadUrl",
5012 default,
5013 skip_serializing_if = "Option::is_none"
5014 )]
5015 pub logs_download_url: Option<String>,
5016 #[doc = "Orchestration/Plan Id for the maintenance job"]
5017 #[serde(
5018 rename = "orchestrationId",
5019 default,
5020 skip_serializing_if = "Option::is_none"
5021 )]
5022 pub orchestration_id: Option<String>,
5023 #[serde(default, skip_serializing_if = "Option::is_none")]
5024 pub pool: Option<TaskAgentPoolReference>,
5025 #[doc = "Time that the maintenance job was queued"]
5026 #[serde(
5027 rename = "queueTime",
5028 default,
5029 skip_serializing_if = "Option::is_none",
5030 with = "crate::date_time::rfc3339::option"
5031 )]
5032 pub queue_time: Option<time::OffsetDateTime>,
5033 #[serde(
5034 rename = "requestedBy",
5035 default,
5036 skip_serializing_if = "Option::is_none"
5037 )]
5038 pub requested_by: Option<IdentityRef>,
5039 #[doc = "The maintenance job result"]
5040 #[serde(default, skip_serializing_if = "Option::is_none")]
5041 pub result: Option<task_agent_pool_maintenance_job::Result>,
5042 #[doc = "Time that the maintenance job was started"]
5043 #[serde(
5044 rename = "startTime",
5045 default,
5046 skip_serializing_if = "Option::is_none",
5047 with = "crate::date_time::rfc3339::option"
5048 )]
5049 pub start_time: Option<time::OffsetDateTime>,
5050 #[doc = "Status of the maintenance job"]
5051 #[serde(default, skip_serializing_if = "Option::is_none")]
5052 pub status: Option<task_agent_pool_maintenance_job::Status>,
5053 #[serde(
5054 rename = "targetAgents",
5055 default,
5056 deserialize_with = "crate::serde::deserialize_null_as_default",
5057 skip_serializing_if = "Vec::is_empty"
5058 )]
5059 pub target_agents: Vec<TaskAgentPoolMaintenanceJobTargetAgent>,
5060 #[doc = "The total warning counts during the maintenance job"]
5061 #[serde(
5062 rename = "warningCount",
5063 default,
5064 skip_serializing_if = "Option::is_none"
5065 )]
5066 pub warning_count: Option<i32>,
5067}
5068impl TaskAgentPoolMaintenanceJob {
5069 pub fn new() -> Self {
5070 Self::default()
5071 }
5072}
5073pub mod task_agent_pool_maintenance_job {
5074 use super::*;
5075 #[doc = "The maintenance job result"]
5076 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5077 pub enum Result {
5078 #[serde(rename = "succeeded")]
5079 Succeeded,
5080 #[serde(rename = "failed")]
5081 Failed,
5082 #[serde(rename = "canceled")]
5083 Canceled,
5084 }
5085 #[doc = "Status of the maintenance job"]
5086 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5087 pub enum Status {
5088 #[serde(rename = "inProgress")]
5089 InProgress,
5090 #[serde(rename = "completed")]
5091 Completed,
5092 #[serde(rename = "cancelling")]
5093 Cancelling,
5094 #[serde(rename = "queued")]
5095 Queued,
5096 }
5097}
5098#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5099pub struct TaskAgentPoolMaintenanceJobTargetAgent {
5100 #[doc = "A reference to an agent."]
5101 #[serde(default, skip_serializing_if = "Option::is_none")]
5102 pub agent: Option<TaskAgentReference>,
5103 #[serde(rename = "jobId", default, skip_serializing_if = "Option::is_none")]
5104 pub job_id: Option<i32>,
5105 #[serde(default, skip_serializing_if = "Option::is_none")]
5106 pub result: Option<task_agent_pool_maintenance_job_target_agent::Result>,
5107 #[serde(default, skip_serializing_if = "Option::is_none")]
5108 pub status: Option<task_agent_pool_maintenance_job_target_agent::Status>,
5109}
5110impl TaskAgentPoolMaintenanceJobTargetAgent {
5111 pub fn new() -> Self {
5112 Self::default()
5113 }
5114}
5115pub mod task_agent_pool_maintenance_job_target_agent {
5116 use super::*;
5117 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5118 pub enum Result {
5119 #[serde(rename = "succeeded")]
5120 Succeeded,
5121 #[serde(rename = "failed")]
5122 Failed,
5123 #[serde(rename = "canceled")]
5124 Canceled,
5125 }
5126 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5127 pub enum Status {
5128 #[serde(rename = "inProgress")]
5129 InProgress,
5130 #[serde(rename = "completed")]
5131 Completed,
5132 #[serde(rename = "cancelling")]
5133 Cancelling,
5134 #[serde(rename = "queued")]
5135 Queued,
5136 }
5137}
5138#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5139pub struct TaskAgentPoolMaintenanceOptions {
5140 #[doc = "time to consider a System.DefaultWorkingDirectory is stale"]
5141 #[serde(
5142 rename = "workingDirectoryExpirationInDays",
5143 default,
5144 skip_serializing_if = "Option::is_none"
5145 )]
5146 pub working_directory_expiration_in_days: Option<i32>,
5147}
5148impl TaskAgentPoolMaintenanceOptions {
5149 pub fn new() -> Self {
5150 Self::default()
5151 }
5152}
5153#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5154pub struct TaskAgentPoolMaintenanceRetentionPolicy {
5155 #[doc = "Number of records to keep for maintenance job executed with this definition."]
5156 #[serde(
5157 rename = "numberOfHistoryRecordsToKeep",
5158 default,
5159 skip_serializing_if = "Option::is_none"
5160 )]
5161 pub number_of_history_records_to_keep: Option<i32>,
5162}
5163impl TaskAgentPoolMaintenanceRetentionPolicy {
5164 pub fn new() -> Self {
5165 Self::default()
5166 }
5167}
5168#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5169pub struct TaskAgentPoolMaintenanceSchedule {
5170 #[doc = "Days for a build (flags enum for days of the week)"]
5171 #[serde(
5172 rename = "daysToBuild",
5173 default,
5174 skip_serializing_if = "Option::is_none"
5175 )]
5176 pub days_to_build: Option<task_agent_pool_maintenance_schedule::DaysToBuild>,
5177 #[doc = "The Job Id of the Scheduled job that will queue the pool maintenance job."]
5178 #[serde(
5179 rename = "scheduleJobId",
5180 default,
5181 skip_serializing_if = "Option::is_none"
5182 )]
5183 pub schedule_job_id: Option<String>,
5184 #[doc = "Local timezone hour to start"]
5185 #[serde(
5186 rename = "startHours",
5187 default,
5188 skip_serializing_if = "Option::is_none"
5189 )]
5190 pub start_hours: Option<i32>,
5191 #[doc = "Local timezone minute to start"]
5192 #[serde(
5193 rename = "startMinutes",
5194 default,
5195 skip_serializing_if = "Option::is_none"
5196 )]
5197 pub start_minutes: Option<i32>,
5198 #[doc = "Time zone of the build schedule (string representation of the time zone id)"]
5199 #[serde(
5200 rename = "timeZoneId",
5201 default,
5202 skip_serializing_if = "Option::is_none"
5203 )]
5204 pub time_zone_id: Option<String>,
5205}
5206impl TaskAgentPoolMaintenanceSchedule {
5207 pub fn new() -> Self {
5208 Self::default()
5209 }
5210}
5211pub mod task_agent_pool_maintenance_schedule {
5212 use super::*;
5213 #[doc = "Days for a build (flags enum for days of the week)"]
5214 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5215 pub enum DaysToBuild {
5216 #[serde(rename = "none")]
5217 None,
5218 #[serde(rename = "monday")]
5219 Monday,
5220 #[serde(rename = "tuesday")]
5221 Tuesday,
5222 #[serde(rename = "wednesday")]
5223 Wednesday,
5224 #[serde(rename = "thursday")]
5225 Thursday,
5226 #[serde(rename = "friday")]
5227 Friday,
5228 #[serde(rename = "saturday")]
5229 Saturday,
5230 #[serde(rename = "sunday")]
5231 Sunday,
5232 #[serde(rename = "all")]
5233 All,
5234 }
5235}
5236#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5237pub struct TaskAgentPoolReference {
5238 #[serde(default, skip_serializing_if = "Option::is_none")]
5239 pub id: Option<i32>,
5240 #[doc = "Gets or sets a value indicating whether or not this pool is managed by the service."]
5241 #[serde(rename = "isHosted", default, skip_serializing_if = "Option::is_none")]
5242 pub is_hosted: Option<bool>,
5243 #[doc = "Determines whether the pool is legacy."]
5244 #[serde(rename = "isLegacy", default, skip_serializing_if = "Option::is_none")]
5245 pub is_legacy: Option<bool>,
5246 #[serde(default, skip_serializing_if = "Option::is_none")]
5247 pub name: Option<String>,
5248 #[doc = "Additional pool settings and details"]
5249 #[serde(default, skip_serializing_if = "Option::is_none")]
5250 pub options: Option<task_agent_pool_reference::Options>,
5251 #[doc = "Gets or sets the type of the pool"]
5252 #[serde(rename = "poolType", default, skip_serializing_if = "Option::is_none")]
5253 pub pool_type: Option<task_agent_pool_reference::PoolType>,
5254 #[serde(default, skip_serializing_if = "Option::is_none")]
5255 pub scope: Option<String>,
5256 #[doc = "Gets the current size of the pool."]
5257 #[serde(default, skip_serializing_if = "Option::is_none")]
5258 pub size: Option<i32>,
5259}
5260impl TaskAgentPoolReference {
5261 pub fn new() -> Self {
5262 Self::default()
5263 }
5264}
5265pub mod task_agent_pool_reference {
5266 use super::*;
5267 #[doc = "Additional pool settings and details"]
5268 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5269 pub enum Options {
5270 #[serde(rename = "none")]
5271 None,
5272 #[serde(rename = "elasticPool")]
5273 ElasticPool,
5274 #[serde(rename = "singleUseAgents")]
5275 SingleUseAgents,
5276 #[serde(rename = "preserveAgentOnJobFailure")]
5277 PreserveAgentOnJobFailure,
5278 }
5279 #[doc = "Gets or sets the type of the pool"]
5280 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5281 pub enum PoolType {
5282 #[serde(rename = "automation")]
5283 Automation,
5284 #[serde(rename = "deployment")]
5285 Deployment,
5286 }
5287}
5288#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5289pub struct TaskAgentPoolStatus {
5290 #[serde(flatten)]
5291 pub task_agent_pool_reference: TaskAgentPoolReference,
5292 #[doc = "Number of requests queued and assigned to an agent. Not running yet."]
5293 #[serde(
5294 rename = "assignedRequestCount",
5295 default,
5296 skip_serializing_if = "Option::is_none"
5297 )]
5298 pub assigned_request_count: Option<i32>,
5299 #[doc = "Number of queued requests which are not assigned to any agents"]
5300 #[serde(
5301 rename = "queuedRequestCount",
5302 default,
5303 skip_serializing_if = "Option::is_none"
5304 )]
5305 pub queued_request_count: Option<i32>,
5306 #[doc = "Number of currently running requests"]
5307 #[serde(
5308 rename = "runningRequestCount",
5309 default,
5310 skip_serializing_if = "Option::is_none"
5311 )]
5312 pub running_request_count: Option<i32>,
5313}
5314impl TaskAgentPoolStatus {
5315 pub fn new() -> Self {
5316 Self::default()
5317 }
5318}
5319#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5320pub struct TaskAgentPoolSummary {
5321 #[doc = "Metrics columns header"]
5322 #[serde(
5323 rename = "columnsHeader",
5324 default,
5325 skip_serializing_if = "Option::is_none"
5326 )]
5327 pub columns_header: Option<MetricsColumnsHeader>,
5328 #[serde(
5329 rename = "deploymentGroups",
5330 default,
5331 deserialize_with = "crate::serde::deserialize_null_as_default",
5332 skip_serializing_if = "Vec::is_empty"
5333 )]
5334 pub deployment_groups: Vec<DeploymentGroupReference>,
5335 #[serde(default, skip_serializing_if = "Option::is_none")]
5336 pub pool: Option<TaskAgentPoolReference>,
5337 #[serde(
5338 default,
5339 deserialize_with = "crate::serde::deserialize_null_as_default",
5340 skip_serializing_if = "Vec::is_empty"
5341 )]
5342 pub queues: Vec<TaskAgentQueue>,
5343 #[serde(
5344 default,
5345 deserialize_with = "crate::serde::deserialize_null_as_default",
5346 skip_serializing_if = "Vec::is_empty"
5347 )]
5348 pub rows: Vec<MetricsRow>,
5349}
5350impl TaskAgentPoolSummary {
5351 pub fn new() -> Self {
5352 Self::default()
5353 }
5354}
5355#[doc = "Represents the public key portion of an RSA asymmetric key."]
5356#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5357pub struct TaskAgentPublicKey {
5358 #[doc = "Gets or sets the exponent for the public key."]
5359 #[serde(
5360 default,
5361 deserialize_with = "crate::serde::deserialize_null_as_default",
5362 skip_serializing_if = "Vec::is_empty"
5363 )]
5364 pub exponent: Vec<String>,
5365 #[doc = "Gets or sets the modulus for the public key."]
5366 #[serde(
5367 default,
5368 deserialize_with = "crate::serde::deserialize_null_as_default",
5369 skip_serializing_if = "Vec::is_empty"
5370 )]
5371 pub modulus: Vec<String>,
5372}
5373impl TaskAgentPublicKey {
5374 pub fn new() -> Self {
5375 Self::default()
5376 }
5377}
5378#[doc = "An agent queue."]
5379#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5380pub struct TaskAgentQueue {
5381 #[doc = "ID of the queue"]
5382 #[serde(default, skip_serializing_if = "Option::is_none")]
5383 pub id: Option<i32>,
5384 #[doc = "Name of the queue"]
5385 #[serde(default, skip_serializing_if = "Option::is_none")]
5386 pub name: Option<String>,
5387 #[serde(default, skip_serializing_if = "Option::is_none")]
5388 pub pool: Option<TaskAgentPoolReference>,
5389 #[doc = "Project ID"]
5390 #[serde(rename = "projectId", default, skip_serializing_if = "Option::is_none")]
5391 pub project_id: Option<String>,
5392}
5393impl TaskAgentQueue {
5394 pub fn new() -> Self {
5395 Self::default()
5396 }
5397}
5398#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5399pub struct TaskAgentQueueList {
5400 #[serde(default, skip_serializing_if = "Option::is_none")]
5401 pub count: Option<i32>,
5402 #[serde(
5403 default,
5404 deserialize_with = "crate::serde::deserialize_null_as_default",
5405 skip_serializing_if = "Vec::is_empty"
5406 )]
5407 pub value: Vec<TaskAgentQueue>,
5408}
5409impl TaskAgentQueueList {
5410 pub fn new() -> Self {
5411 Self::default()
5412 }
5413}
5414#[doc = "A reference to an agent."]
5415#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5416pub struct TaskAgentReference {
5417 #[doc = "The class to represent a collection of REST reference links."]
5418 #[serde(rename = "_links", default, skip_serializing_if = "Option::is_none")]
5419 pub links: Option<ReferenceLinks>,
5420 #[doc = "This agent's access point."]
5421 #[serde(
5422 rename = "accessPoint",
5423 default,
5424 skip_serializing_if = "Option::is_none"
5425 )]
5426 pub access_point: Option<String>,
5427 #[doc = "Whether or not this agent should run jobs."]
5428 #[serde(default, skip_serializing_if = "Option::is_none")]
5429 pub enabled: Option<bool>,
5430 #[doc = "Identifier of the agent."]
5431 #[serde(default, skip_serializing_if = "Option::is_none")]
5432 pub id: Option<i32>,
5433 #[doc = "Name of the agent."]
5434 #[serde(default, skip_serializing_if = "Option::is_none")]
5435 pub name: Option<String>,
5436 #[doc = "Agent OS."]
5437 #[serde(
5438 rename = "osDescription",
5439 default,
5440 skip_serializing_if = "Option::is_none"
5441 )]
5442 pub os_description: Option<String>,
5443 #[doc = "Provisioning state of this agent."]
5444 #[serde(
5445 rename = "provisioningState",
5446 default,
5447 skip_serializing_if = "Option::is_none"
5448 )]
5449 pub provisioning_state: Option<String>,
5450 #[doc = "Whether or not the agent is online."]
5451 #[serde(default, skip_serializing_if = "Option::is_none")]
5452 pub status: Option<task_agent_reference::Status>,
5453 #[doc = "Agent version."]
5454 #[serde(default, skip_serializing_if = "Option::is_none")]
5455 pub version: Option<String>,
5456}
5457impl TaskAgentReference {
5458 pub fn new() -> Self {
5459 Self::default()
5460 }
5461}
5462pub mod task_agent_reference {
5463 use super::*;
5464 #[doc = "Whether or not the agent is online."]
5465 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5466 pub enum Status {
5467 #[serde(rename = "offline")]
5468 Offline,
5469 #[serde(rename = "online")]
5470 Online,
5471 }
5472}
5473#[doc = "Represents a session for performing message exchanges from an agent."]
5474#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5475pub struct TaskAgentSession {
5476 #[doc = "A reference to an agent."]
5477 #[serde(default, skip_serializing_if = "Option::is_none")]
5478 pub agent: Option<TaskAgentReference>,
5479 #[doc = "Represents a symmetric key used for message-level encryption for communication sent to an agent."]
5480 #[serde(
5481 rename = "encryptionKey",
5482 default,
5483 skip_serializing_if = "Option::is_none"
5484 )]
5485 pub encryption_key: Option<TaskAgentSessionKey>,
5486 #[doc = "Gets or sets the owner name of this session. Generally this will be the machine of origination."]
5487 #[serde(rename = "ownerName", default, skip_serializing_if = "Option::is_none")]
5488 pub owner_name: Option<String>,
5489 #[doc = "Gets the unique identifier for this session."]
5490 #[serde(rename = "sessionId", default, skip_serializing_if = "Option::is_none")]
5491 pub session_id: Option<String>,
5492 #[serde(
5493 rename = "systemCapabilities",
5494 default,
5495 skip_serializing_if = "Option::is_none"
5496 )]
5497 pub system_capabilities: Option<serde_json::Value>,
5498}
5499impl TaskAgentSession {
5500 pub fn new() -> Self {
5501 Self::default()
5502 }
5503}
5504#[doc = "Represents a symmetric key used for message-level encryption for communication sent to an agent."]
5505#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5506pub struct TaskAgentSessionKey {
5507 #[doc = "Gets or sets a value indicating whether or not the key value is encrypted. If this value is true, the Value property should be decrypted using the <c>RSA</c> key exchanged with the server during registration."]
5508 #[serde(default, skip_serializing_if = "Option::is_none")]
5509 pub encrypted: Option<bool>,
5510 #[doc = "Gets or sets the symmetric key value."]
5511 #[serde(
5512 default,
5513 deserialize_with = "crate::serde::deserialize_null_as_default",
5514 skip_serializing_if = "Vec::is_empty"
5515 )]
5516 pub value: Vec<String>,
5517}
5518impl TaskAgentSessionKey {
5519 pub fn new() -> Self {
5520 Self::default()
5521 }
5522}
5523#[doc = "Details about an agent update."]
5524#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5525pub struct TaskAgentUpdate {
5526 #[doc = "Current state of this agent update."]
5527 #[serde(
5528 rename = "currentState",
5529 default,
5530 skip_serializing_if = "Option::is_none"
5531 )]
5532 pub current_state: Option<String>,
5533 #[serde(default, skip_serializing_if = "Option::is_none")]
5534 pub reason: Option<TaskAgentUpdateReason>,
5535 #[serde(
5536 rename = "requestedBy",
5537 default,
5538 skip_serializing_if = "Option::is_none"
5539 )]
5540 pub requested_by: Option<IdentityRef>,
5541 #[doc = "Date on which this update was requested."]
5542 #[serde(
5543 rename = "requestTime",
5544 default,
5545 skip_serializing_if = "Option::is_none",
5546 with = "crate::date_time::rfc3339::option"
5547 )]
5548 pub request_time: Option<time::OffsetDateTime>,
5549 #[serde(
5550 rename = "sourceVersion",
5551 default,
5552 skip_serializing_if = "Option::is_none"
5553 )]
5554 pub source_version: Option<PackageVersion>,
5555 #[serde(
5556 rename = "targetVersion",
5557 default,
5558 skip_serializing_if = "Option::is_none"
5559 )]
5560 pub target_version: Option<PackageVersion>,
5561}
5562impl TaskAgentUpdate {
5563 pub fn new() -> Self {
5564 Self::default()
5565 }
5566}
5567#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5568pub struct TaskAgentUpdateReason {
5569 #[serde(default, skip_serializing_if = "Option::is_none")]
5570 pub code: Option<task_agent_update_reason::Code>,
5571}
5572impl TaskAgentUpdateReason {
5573 pub fn new() -> Self {
5574 Self::default()
5575 }
5576}
5577pub mod task_agent_update_reason {
5578 use super::*;
5579 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5580 pub enum Code {
5581 #[serde(rename = "manual")]
5582 Manual,
5583 #[serde(rename = "minAgentVersionRequired")]
5584 MinAgentVersionRequired,
5585 #[serde(rename = "downgrade")]
5586 Downgrade,
5587 }
5588}
5589#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5590pub struct TaskAssignedEvent {
5591 #[serde(flatten)]
5592 pub task_event: TaskEvent,
5593}
5594impl TaskAssignedEvent {
5595 pub fn new() -> Self {
5596 Self::default()
5597 }
5598}
5599#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5600pub struct TaskAttachment {
5601 #[doc = "The class to represent a collection of REST reference links."]
5602 #[serde(rename = "_links", default, skip_serializing_if = "Option::is_none")]
5603 pub links: Option<ReferenceLinks>,
5604 #[serde(
5605 rename = "createdOn",
5606 default,
5607 skip_serializing_if = "Option::is_none",
5608 with = "crate::date_time::rfc3339::option"
5609 )]
5610 pub created_on: Option<time::OffsetDateTime>,
5611 #[serde(
5612 rename = "lastChangedBy",
5613 default,
5614 skip_serializing_if = "Option::is_none"
5615 )]
5616 pub last_changed_by: Option<String>,
5617 #[serde(
5618 rename = "lastChangedOn",
5619 default,
5620 skip_serializing_if = "Option::is_none",
5621 with = "crate::date_time::rfc3339::option"
5622 )]
5623 pub last_changed_on: Option<time::OffsetDateTime>,
5624 #[serde(default, skip_serializing_if = "Option::is_none")]
5625 pub name: Option<String>,
5626 #[serde(rename = "recordId", default, skip_serializing_if = "Option::is_none")]
5627 pub record_id: Option<String>,
5628 #[serde(
5629 rename = "timelineId",
5630 default,
5631 skip_serializing_if = "Option::is_none"
5632 )]
5633 pub timeline_id: Option<String>,
5634 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
5635 pub type_: Option<String>,
5636}
5637impl TaskAttachment {
5638 pub fn new() -> Self {
5639 Self::default()
5640 }
5641}
5642#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5643pub struct TaskCommandRestrictions {
5644 #[serde(default, skip_serializing_if = "Option::is_none")]
5645 pub mode: Option<task_command_restrictions::Mode>,
5646}
5647impl TaskCommandRestrictions {
5648 pub fn new() -> Self {
5649 Self::default()
5650 }
5651}
5652pub mod task_command_restrictions {
5653 use super::*;
5654 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5655 pub enum Mode {
5656 #[serde(rename = "any")]
5657 Any,
5658 #[serde(rename = "restricted")]
5659 Restricted,
5660 }
5661}
5662#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5663pub struct TaskCompletedEvent {
5664 #[serde(flatten)]
5665 pub task_event: TaskEvent,
5666 #[doc = "The api request was no delivered successfully"]
5667 #[serde(
5668 rename = "deliveryFailed",
5669 default,
5670 skip_serializing_if = "Option::is_none"
5671 )]
5672 pub delivery_failed: Option<bool>,
5673 #[doc = "The result of the task."]
5674 #[serde(default, skip_serializing_if = "Option::is_none")]
5675 pub result: Option<task_completed_event::Result>,
5676}
5677impl TaskCompletedEvent {
5678 pub fn new() -> Self {
5679 Self::default()
5680 }
5681}
5682pub mod task_completed_event {
5683 use super::*;
5684 #[doc = "The result of the task."]
5685 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
5686 pub enum Result {
5687 #[serde(rename = "succeeded")]
5688 Succeeded,
5689 #[serde(rename = "succeededWithIssues")]
5690 SucceededWithIssues,
5691 #[serde(rename = "failed")]
5692 Failed,
5693 #[serde(rename = "canceled")]
5694 Canceled,
5695 #[serde(rename = "skipped")]
5696 Skipped,
5697 #[serde(rename = "abandoned")]
5698 Abandoned,
5699 }
5700}
5701#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5702pub struct TaskDefinition {
5703 #[serde(
5704 rename = "agentExecution",
5705 default,
5706 skip_serializing_if = "Option::is_none"
5707 )]
5708 pub agent_execution: Option<TaskExecution>,
5709 #[serde(default, skip_serializing_if = "Option::is_none")]
5710 pub author: Option<String>,
5711 #[serde(default, skip_serializing_if = "Option::is_none")]
5712 pub category: Option<String>,
5713 #[serde(
5714 rename = "contentsUploaded",
5715 default,
5716 skip_serializing_if = "Option::is_none"
5717 )]
5718 pub contents_uploaded: Option<bool>,
5719 #[serde(
5720 rename = "contributionIdentifier",
5721 default,
5722 skip_serializing_if = "Option::is_none"
5723 )]
5724 pub contribution_identifier: Option<String>,
5725 #[serde(
5726 rename = "contributionVersion",
5727 default,
5728 skip_serializing_if = "Option::is_none"
5729 )]
5730 pub contribution_version: Option<String>,
5731 #[serde(
5732 rename = "dataSourceBindings",
5733 default,
5734 deserialize_with = "crate::serde::deserialize_null_as_default",
5735 skip_serializing_if = "Vec::is_empty"
5736 )]
5737 pub data_source_bindings: Vec<DataSourceBinding>,
5738 #[serde(
5739 rename = "definitionType",
5740 default,
5741 skip_serializing_if = "Option::is_none"
5742 )]
5743 pub definition_type: Option<String>,
5744 #[serde(
5745 default,
5746 deserialize_with = "crate::serde::deserialize_null_as_default",
5747 skip_serializing_if = "Vec::is_empty"
5748 )]
5749 pub demands: Vec<Demand>,
5750 #[serde(default, skip_serializing_if = "Option::is_none")]
5751 pub deprecated: Option<bool>,
5752 #[serde(default, skip_serializing_if = "Option::is_none")]
5753 pub description: Option<String>,
5754 #[serde(default, skip_serializing_if = "Option::is_none")]
5755 pub disabled: Option<bool>,
5756 #[serde(default, skip_serializing_if = "Option::is_none")]
5757 pub execution: Option<serde_json::Value>,
5758 #[serde(
5759 rename = "friendlyName",
5760 default,
5761 skip_serializing_if = "Option::is_none"
5762 )]
5763 pub friendly_name: Option<String>,
5764 #[serde(
5765 default,
5766 deserialize_with = "crate::serde::deserialize_null_as_default",
5767 skip_serializing_if = "Vec::is_empty"
5768 )]
5769 pub groups: Vec<TaskGroupDefinition>,
5770 #[serde(
5771 rename = "helpMarkDown",
5772 default,
5773 skip_serializing_if = "Option::is_none"
5774 )]
5775 pub help_mark_down: Option<String>,
5776 #[serde(rename = "helpUrl", default, skip_serializing_if = "Option::is_none")]
5777 pub help_url: Option<String>,
5778 #[serde(rename = "hostType", default, skip_serializing_if = "Option::is_none")]
5779 pub host_type: Option<String>,
5780 #[serde(rename = "iconUrl", default, skip_serializing_if = "Option::is_none")]
5781 pub icon_url: Option<String>,
5782 #[serde(default, skip_serializing_if = "Option::is_none")]
5783 pub id: Option<String>,
5784 #[serde(
5785 default,
5786 deserialize_with = "crate::serde::deserialize_null_as_default",
5787 skip_serializing_if = "Vec::is_empty"
5788 )]
5789 pub inputs: Vec<TaskInputDefinition>,
5790 #[serde(
5791 rename = "instanceNameFormat",
5792 default,
5793 skip_serializing_if = "Option::is_none"
5794 )]
5795 pub instance_name_format: Option<String>,
5796 #[serde(
5797 rename = "minimumAgentVersion",
5798 default,
5799 skip_serializing_if = "Option::is_none"
5800 )]
5801 pub minimum_agent_version: Option<String>,
5802 #[serde(default, skip_serializing_if = "Option::is_none")]
5803 pub name: Option<String>,
5804 #[serde(
5805 rename = "outputVariables",
5806 default,
5807 deserialize_with = "crate::serde::deserialize_null_as_default",
5808 skip_serializing_if = "Vec::is_empty"
5809 )]
5810 pub output_variables: Vec<TaskOutputVariable>,
5811 #[serde(
5812 rename = "packageLocation",
5813 default,
5814 skip_serializing_if = "Option::is_none"
5815 )]
5816 pub package_location: Option<String>,
5817 #[serde(
5818 rename = "packageType",
5819 default,
5820 skip_serializing_if = "Option::is_none"
5821 )]
5822 pub package_type: Option<String>,
5823 #[serde(
5824 rename = "postJobExecution",
5825 default,
5826 skip_serializing_if = "Option::is_none"
5827 )]
5828 pub post_job_execution: Option<serde_json::Value>,
5829 #[serde(
5830 rename = "preJobExecution",
5831 default,
5832 skip_serializing_if = "Option::is_none"
5833 )]
5834 pub pre_job_execution: Option<serde_json::Value>,
5835 #[serde(default, skip_serializing_if = "Option::is_none")]
5836 pub preview: Option<bool>,
5837 #[serde(
5838 rename = "releaseNotes",
5839 default,
5840 skip_serializing_if = "Option::is_none"
5841 )]
5842 pub release_notes: Option<String>,
5843 #[serde(default, skip_serializing_if = "Option::is_none")]
5844 pub restrictions: Option<TaskRestrictions>,
5845 #[serde(
5846 rename = "runsOn",
5847 default,
5848 deserialize_with = "crate::serde::deserialize_null_as_default",
5849 skip_serializing_if = "Vec::is_empty"
5850 )]
5851 pub runs_on: Vec<String>,
5852 #[serde(
5853 default,
5854 deserialize_with = "crate::serde::deserialize_null_as_default",
5855 skip_serializing_if = "Vec::is_empty"
5856 )]
5857 pub satisfies: Vec<String>,
5858 #[serde(
5859 rename = "serverOwned",
5860 default,
5861 skip_serializing_if = "Option::is_none"
5862 )]
5863 pub server_owned: Option<bool>,
5864 #[serde(
5865 rename = "showEnvironmentVariables",
5866 default,
5867 skip_serializing_if = "Option::is_none"
5868 )]
5869 pub show_environment_variables: Option<bool>,
5870 #[serde(
5871 rename = "sourceDefinitions",
5872 default,
5873 deserialize_with = "crate::serde::deserialize_null_as_default",
5874 skip_serializing_if = "Vec::is_empty"
5875 )]
5876 pub source_definitions: Vec<TaskSourceDefinition>,
5877 #[serde(
5878 rename = "sourceLocation",
5879 default,
5880 skip_serializing_if = "Option::is_none"
5881 )]
5882 pub source_location: Option<String>,
5883 #[serde(default, skip_serializing_if = "Option::is_none")]
5884 pub version: Option<TaskVersion>,
5885 #[serde(
5886 default,
5887 deserialize_with = "crate::serde::deserialize_null_as_default",
5888 skip_serializing_if = "Vec::is_empty"
5889 )]
5890 pub visibility: Vec<String>,
5891}
5892impl TaskDefinition {
5893 pub fn new() -> Self {
5894 Self::default()
5895 }
5896}
5897#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5898pub struct TaskDefinitionEndpoint {
5899 #[doc = "An ID that identifies a service connection to be used for authenticating endpoint requests."]
5900 #[serde(
5901 rename = "connectionId",
5902 default,
5903 skip_serializing_if = "Option::is_none"
5904 )]
5905 pub connection_id: Option<String>,
5906 #[doc = "An Json based keyselector to filter response returned by fetching the endpoint <c>Url</c>.A Json based keyselector must be prefixed with \"jsonpath:\". KeySelector can be used to specify the filter to get the keys for the values specified with Selector. <example> The following keyselector defines an Json for extracting nodes named 'ServiceName'. <code> endpoint.KeySelector = \"jsonpath://ServiceName\"; </code></example>"]
5907 #[serde(
5908 rename = "keySelector",
5909 default,
5910 skip_serializing_if = "Option::is_none"
5911 )]
5912 pub key_selector: Option<String>,
5913 #[doc = "The scope as understood by Connected Services. Essentially, a project-id for now."]
5914 #[serde(default, skip_serializing_if = "Option::is_none")]
5915 pub scope: Option<String>,
5916 #[doc = "An XPath/Json based selector to filter response returned by fetching the endpoint <c>Url</c>. An XPath based selector must be prefixed with the string \"xpath:\". A Json based selector must be prefixed with \"jsonpath:\". <example> The following selector defines an XPath for extracting nodes named 'ServiceName'. <code> endpoint.Selector = \"xpath://ServiceName\"; </code></example>"]
5917 #[serde(default, skip_serializing_if = "Option::is_none")]
5918 pub selector: Option<String>,
5919 #[doc = "TaskId that this endpoint belongs to."]
5920 #[serde(rename = "taskId", default, skip_serializing_if = "Option::is_none")]
5921 pub task_id: Option<String>,
5922 #[doc = "URL to GET."]
5923 #[serde(default, skip_serializing_if = "Option::is_none")]
5924 pub url: Option<String>,
5925}
5926impl TaskDefinitionEndpoint {
5927 pub fn new() -> Self {
5928 Self::default()
5929 }
5930}
5931#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5932pub struct TaskDefinitionReference {
5933 #[doc = "Gets or sets the definition type. Values can be 'task' or 'metaTask'."]
5934 #[serde(
5935 rename = "definitionType",
5936 default,
5937 skip_serializing_if = "Option::is_none"
5938 )]
5939 pub definition_type: Option<String>,
5940 #[doc = "Gets or sets the unique identifier of task."]
5941 #[serde(default, skip_serializing_if = "Option::is_none")]
5942 pub id: Option<String>,
5943 #[doc = "Gets or sets the version specification of task."]
5944 #[serde(
5945 rename = "versionSpec",
5946 default,
5947 skip_serializing_if = "Option::is_none"
5948 )]
5949 pub version_spec: Option<String>,
5950}
5951impl TaskDefinitionReference {
5952 pub fn new() -> Self {
5953 Self::default()
5954 }
5955}
5956#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5957pub struct TaskEvent {
5958 #[serde(flatten)]
5959 pub job_event: JobEvent,
5960 #[doc = "The ID of the task definition."]
5961 #[serde(rename = "taskId", default, skip_serializing_if = "Option::is_none")]
5962 pub task_id: Option<String>,
5963}
5964impl TaskEvent {
5965 pub fn new() -> Self {
5966 Self::default()
5967 }
5968}
5969#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5970pub struct TaskExecution {
5971 #[doc = "A reference to a task."]
5972 #[serde(rename = "execTask", default, skip_serializing_if = "Option::is_none")]
5973 pub exec_task: Option<TaskReference>,
5974 #[doc = "If a task is going to run code, then this provides the type/script etc... information by platform. For example, it might look like. net45: { typeName: \"Microsoft.TeamFoundation.Automation.Tasks.PowerShellTask\", assemblyName: \"Microsoft.TeamFoundation.Automation.Tasks.PowerShell.dll\" } net20: { typeName: \"Microsoft.TeamFoundation.Automation.Tasks.PowerShellTask\", assemblyName: \"Microsoft.TeamFoundation.Automation.Tasks.PowerShell.dll\" } java: { jar: \"powershelltask.tasks.automation.teamfoundation.microsoft.com\", } node: { script: \"powershellhost.js\", }"]
5975 #[serde(
5976 rename = "platformInstructions",
5977 default,
5978 skip_serializing_if = "Option::is_none"
5979 )]
5980 pub platform_instructions: Option<serde_json::Value>,
5981}
5982impl TaskExecution {
5983 pub fn new() -> Self {
5984 Self::default()
5985 }
5986}
5987#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
5988pub struct TaskGroup {
5989 #[serde(flatten)]
5990 pub task_definition: TaskDefinition,
5991 #[doc = "Gets or sets comment."]
5992 #[serde(default, skip_serializing_if = "Option::is_none")]
5993 pub comment: Option<String>,
5994 #[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
5995 pub created_by: Option<IdentityRef>,
5996 #[doc = "Gets or sets date on which it got created."]
5997 #[serde(
5998 rename = "createdOn",
5999 default,
6000 skip_serializing_if = "Option::is_none",
6001 with = "crate::date_time::rfc3339::option"
6002 )]
6003 pub created_on: Option<time::OffsetDateTime>,
6004 #[doc = "Gets or sets as 'true' to indicate as deleted, 'false' otherwise."]
6005 #[serde(default, skip_serializing_if = "Option::is_none")]
6006 pub deleted: Option<bool>,
6007 #[serde(
6008 rename = "modifiedBy",
6009 default,
6010 skip_serializing_if = "Option::is_none"
6011 )]
6012 pub modified_by: Option<IdentityRef>,
6013 #[doc = "Gets or sets date on which it got modified."]
6014 #[serde(
6015 rename = "modifiedOn",
6016 default,
6017 skip_serializing_if = "Option::is_none",
6018 with = "crate::date_time::rfc3339::option"
6019 )]
6020 pub modified_on: Option<time::OffsetDateTime>,
6021 #[doc = "Gets or sets the owner."]
6022 #[serde(default, skip_serializing_if = "Option::is_none")]
6023 pub owner: Option<String>,
6024 #[doc = "Gets or sets parent task group Id. This is used while creating a draft task group."]
6025 #[serde(
6026 rename = "parentDefinitionId",
6027 default,
6028 skip_serializing_if = "Option::is_none"
6029 )]
6030 pub parent_definition_id: Option<String>,
6031 #[doc = "Gets or sets revision."]
6032 #[serde(default, skip_serializing_if = "Option::is_none")]
6033 pub revision: Option<i32>,
6034 #[doc = "Gets or sets the tasks."]
6035 #[serde(
6036 default,
6037 deserialize_with = "crate::serde::deserialize_null_as_default",
6038 skip_serializing_if = "Vec::is_empty"
6039 )]
6040 pub tasks: Vec<TaskGroupStep>,
6041}
6042impl TaskGroup {
6043 pub fn new() -> Self {
6044 Self::default()
6045 }
6046}
6047#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6048pub struct TaskGroupCreateParameter {
6049 #[doc = "Sets author name of the task group."]
6050 #[serde(default, skip_serializing_if = "Option::is_none")]
6051 pub author: Option<String>,
6052 #[doc = "Sets category of the task group."]
6053 #[serde(default, skip_serializing_if = "Option::is_none")]
6054 pub category: Option<String>,
6055 #[doc = "Sets description of the task group."]
6056 #[serde(default, skip_serializing_if = "Option::is_none")]
6057 pub description: Option<String>,
6058 #[doc = "Sets friendly name of the task group."]
6059 #[serde(
6060 rename = "friendlyName",
6061 default,
6062 skip_serializing_if = "Option::is_none"
6063 )]
6064 pub friendly_name: Option<String>,
6065 #[doc = "Sets url icon of the task group."]
6066 #[serde(rename = "iconUrl", default, skip_serializing_if = "Option::is_none")]
6067 pub icon_url: Option<String>,
6068 #[doc = "Sets input for the task group."]
6069 #[serde(
6070 default,
6071 deserialize_with = "crate::serde::deserialize_null_as_default",
6072 skip_serializing_if = "Vec::is_empty"
6073 )]
6074 pub inputs: Vec<TaskInputDefinition>,
6075 #[doc = "Sets display name of the task group."]
6076 #[serde(
6077 rename = "instanceNameFormat",
6078 default,
6079 skip_serializing_if = "Option::is_none"
6080 )]
6081 pub instance_name_format: Option<String>,
6082 #[doc = "Sets name of the task group."]
6083 #[serde(default, skip_serializing_if = "Option::is_none")]
6084 pub name: Option<String>,
6085 #[doc = "Sets parent task group Id. This is used while creating a draft task group."]
6086 #[serde(
6087 rename = "parentDefinitionId",
6088 default,
6089 skip_serializing_if = "Option::is_none"
6090 )]
6091 pub parent_definition_id: Option<String>,
6092 #[doc = "Sets RunsOn of the task group. Value can be 'Agent', 'Server' or 'DeploymentGroup'."]
6093 #[serde(
6094 rename = "runsOn",
6095 default,
6096 deserialize_with = "crate::serde::deserialize_null_as_default",
6097 skip_serializing_if = "Vec::is_empty"
6098 )]
6099 pub runs_on: Vec<String>,
6100 #[doc = "Sets tasks for the task group."]
6101 #[serde(
6102 default,
6103 deserialize_with = "crate::serde::deserialize_null_as_default",
6104 skip_serializing_if = "Vec::is_empty"
6105 )]
6106 pub tasks: Vec<TaskGroupStep>,
6107 #[serde(default, skip_serializing_if = "Option::is_none")]
6108 pub version: Option<TaskVersion>,
6109}
6110impl TaskGroupCreateParameter {
6111 pub fn new() -> Self {
6112 Self::default()
6113 }
6114}
6115#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6116pub struct TaskGroupDefinition {
6117 #[serde(
6118 rename = "displayName",
6119 default,
6120 skip_serializing_if = "Option::is_none"
6121 )]
6122 pub display_name: Option<String>,
6123 #[serde(
6124 rename = "isExpanded",
6125 default,
6126 skip_serializing_if = "Option::is_none"
6127 )]
6128 pub is_expanded: Option<bool>,
6129 #[serde(default, skip_serializing_if = "Option::is_none")]
6130 pub name: Option<String>,
6131 #[serde(
6132 default,
6133 deserialize_with = "crate::serde::deserialize_null_as_default",
6134 skip_serializing_if = "Vec::is_empty"
6135 )]
6136 pub tags: Vec<String>,
6137 #[serde(
6138 rename = "visibleRule",
6139 default,
6140 skip_serializing_if = "Option::is_none"
6141 )]
6142 pub visible_rule: Option<String>,
6143}
6144impl TaskGroupDefinition {
6145 pub fn new() -> Self {
6146 Self::default()
6147 }
6148}
6149#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6150pub struct TaskGroupList {
6151 #[serde(default, skip_serializing_if = "Option::is_none")]
6152 pub count: Option<i32>,
6153 #[serde(
6154 default,
6155 deserialize_with = "crate::serde::deserialize_null_as_default",
6156 skip_serializing_if = "Vec::is_empty"
6157 )]
6158 pub value: Vec<TaskGroup>,
6159}
6160impl TaskGroupList {
6161 pub fn new() -> Self {
6162 Self::default()
6163 }
6164}
6165#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6166pub struct TaskGroupPublishPreviewParameter {
6167 #[serde(flatten)]
6168 pub task_group_update_properties_base: TaskGroupUpdatePropertiesBase,
6169 #[doc = "This is to disable previous versions of task group upon publish"]
6170 #[serde(
6171 rename = "disablePriorVersions",
6172 default,
6173 skip_serializing_if = "Option::is_none"
6174 )]
6175 pub disable_prior_versions: Option<bool>,
6176 #[doc = "Denotes if task group is in preview"]
6177 #[serde(default, skip_serializing_if = "Option::is_none")]
6178 pub preview: Option<bool>,
6179 #[doc = "This is the revision of task group that is getting published"]
6180 #[serde(default, skip_serializing_if = "Option::is_none")]
6181 pub revision: Option<i32>,
6182 #[serde(default, skip_serializing_if = "Option::is_none")]
6183 pub version: Option<TaskVersion>,
6184}
6185impl TaskGroupPublishPreviewParameter {
6186 pub fn new() -> Self {
6187 Self::default()
6188 }
6189}
6190#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6191pub struct TaskGroupRestoreParameter {
6192 #[serde(flatten)]
6193 pub task_group_update_properties_base: TaskGroupUpdatePropertiesBase,
6194 #[doc = "This is to restore deleted Task Group"]
6195 #[serde(default, skip_serializing_if = "Option::is_none")]
6196 pub restore: Option<bool>,
6197}
6198impl TaskGroupRestoreParameter {
6199 pub fn new() -> Self {
6200 Self::default()
6201 }
6202}
6203#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6204pub struct TaskGroupRevision {
6205 #[serde(rename = "changedBy", default, skip_serializing_if = "Option::is_none")]
6206 pub changed_by: Option<IdentityRef>,
6207 #[serde(
6208 rename = "changedDate",
6209 default,
6210 skip_serializing_if = "Option::is_none",
6211 with = "crate::date_time::rfc3339::option"
6212 )]
6213 pub changed_date: Option<time::OffsetDateTime>,
6214 #[serde(
6215 rename = "changeType",
6216 default,
6217 skip_serializing_if = "Option::is_none"
6218 )]
6219 pub change_type: Option<task_group_revision::ChangeType>,
6220 #[serde(default, skip_serializing_if = "Option::is_none")]
6221 pub comment: Option<String>,
6222 #[serde(rename = "fileId", default, skip_serializing_if = "Option::is_none")]
6223 pub file_id: Option<i32>,
6224 #[serde(
6225 rename = "majorVersion",
6226 default,
6227 skip_serializing_if = "Option::is_none"
6228 )]
6229 pub major_version: Option<i32>,
6230 #[serde(default, skip_serializing_if = "Option::is_none")]
6231 pub revision: Option<i32>,
6232 #[serde(
6233 rename = "taskGroupId",
6234 default,
6235 skip_serializing_if = "Option::is_none"
6236 )]
6237 pub task_group_id: Option<String>,
6238}
6239impl TaskGroupRevision {
6240 pub fn new() -> Self {
6241 Self::default()
6242 }
6243}
6244pub mod task_group_revision {
6245 use super::*;
6246 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
6247 pub enum ChangeType {
6248 #[serde(rename = "add")]
6249 Add,
6250 #[serde(rename = "update")]
6251 Update,
6252 #[serde(rename = "delete")]
6253 Delete,
6254 #[serde(rename = "undelete")]
6255 Undelete,
6256 }
6257}
6258#[doc = "Represents tasks in the task group."]
6259#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6260pub struct TaskGroupStep {
6261 #[doc = "Gets or sets as 'true' to run the task always, 'false' otherwise."]
6262 #[serde(rename = "alwaysRun", default, skip_serializing_if = "Option::is_none")]
6263 pub always_run: Option<bool>,
6264 #[doc = "Gets or sets condition for the task."]
6265 #[serde(default, skip_serializing_if = "Option::is_none")]
6266 pub condition: Option<String>,
6267 #[doc = "Gets or sets as 'true' to continue on error, 'false' otherwise."]
6268 #[serde(
6269 rename = "continueOnError",
6270 default,
6271 skip_serializing_if = "Option::is_none"
6272 )]
6273 pub continue_on_error: Option<bool>,
6274 #[doc = "Gets or sets the display name."]
6275 #[serde(
6276 rename = "displayName",
6277 default,
6278 skip_serializing_if = "Option::is_none"
6279 )]
6280 pub display_name: Option<String>,
6281 #[doc = "Gets or sets as task is enabled or not."]
6282 #[serde(default, skip_serializing_if = "Option::is_none")]
6283 pub enabled: Option<bool>,
6284 #[doc = "Gets dictionary of environment variables."]
6285 #[serde(default, skip_serializing_if = "Option::is_none")]
6286 pub environment: Option<serde_json::Value>,
6287 #[doc = "Gets or sets dictionary of inputs."]
6288 #[serde(default, skip_serializing_if = "Option::is_none")]
6289 pub inputs: Option<serde_json::Value>,
6290 #[doc = "Gets or sets the maximum number of retries"]
6291 #[serde(
6292 rename = "retryCountOnTaskFailure",
6293 default,
6294 skip_serializing_if = "Option::is_none"
6295 )]
6296 pub retry_count_on_task_failure: Option<i32>,
6297 #[serde(default, skip_serializing_if = "Option::is_none")]
6298 pub task: Option<TaskDefinitionReference>,
6299 #[doc = "Gets or sets the maximum time, in minutes, that a task is allowed to execute on agent before being cancelled by server. A zero value indicates an infinite timeout."]
6300 #[serde(
6301 rename = "timeoutInMinutes",
6302 default,
6303 skip_serializing_if = "Option::is_none"
6304 )]
6305 pub timeout_in_minutes: Option<i32>,
6306}
6307impl TaskGroupStep {
6308 pub fn new() -> Self {
6309 Self::default()
6310 }
6311}
6312#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6313pub struct TaskGroupUpdateParameter {
6314 #[doc = "Sets author name of the task group."]
6315 #[serde(default, skip_serializing_if = "Option::is_none")]
6316 pub author: Option<String>,
6317 #[doc = "Sets category of the task group."]
6318 #[serde(default, skip_serializing_if = "Option::is_none")]
6319 pub category: Option<String>,
6320 #[doc = "Sets comment of the task group."]
6321 #[serde(default, skip_serializing_if = "Option::is_none")]
6322 pub comment: Option<String>,
6323 #[doc = "Sets description of the task group."]
6324 #[serde(default, skip_serializing_if = "Option::is_none")]
6325 pub description: Option<String>,
6326 #[doc = "Sets friendly name of the task group."]
6327 #[serde(
6328 rename = "friendlyName",
6329 default,
6330 skip_serializing_if = "Option::is_none"
6331 )]
6332 pub friendly_name: Option<String>,
6333 #[doc = "Sets url icon of the task group."]
6334 #[serde(rename = "iconUrl", default, skip_serializing_if = "Option::is_none")]
6335 pub icon_url: Option<String>,
6336 #[doc = "Sets the unique identifier of this field."]
6337 #[serde(default, skip_serializing_if = "Option::is_none")]
6338 pub id: Option<String>,
6339 #[doc = "Sets input for the task group."]
6340 #[serde(
6341 default,
6342 deserialize_with = "crate::serde::deserialize_null_as_default",
6343 skip_serializing_if = "Vec::is_empty"
6344 )]
6345 pub inputs: Vec<TaskInputDefinition>,
6346 #[doc = "Sets display name of the task group."]
6347 #[serde(
6348 rename = "instanceNameFormat",
6349 default,
6350 skip_serializing_if = "Option::is_none"
6351 )]
6352 pub instance_name_format: Option<String>,
6353 #[doc = "Sets name of the task group."]
6354 #[serde(default, skip_serializing_if = "Option::is_none")]
6355 pub name: Option<String>,
6356 #[doc = "Gets or sets parent task group Id. This is used while creating a draft task group."]
6357 #[serde(
6358 rename = "parentDefinitionId",
6359 default,
6360 skip_serializing_if = "Option::is_none"
6361 )]
6362 pub parent_definition_id: Option<String>,
6363 #[doc = "Sets revision of the task group."]
6364 #[serde(default, skip_serializing_if = "Option::is_none")]
6365 pub revision: Option<i32>,
6366 #[doc = "Sets RunsOn of the task group. Value can be 'Agent', 'Server' or 'DeploymentGroup'."]
6367 #[serde(
6368 rename = "runsOn",
6369 default,
6370 deserialize_with = "crate::serde::deserialize_null_as_default",
6371 skip_serializing_if = "Vec::is_empty"
6372 )]
6373 pub runs_on: Vec<String>,
6374 #[doc = "Sets tasks for the task group."]
6375 #[serde(
6376 default,
6377 deserialize_with = "crate::serde::deserialize_null_as_default",
6378 skip_serializing_if = "Vec::is_empty"
6379 )]
6380 pub tasks: Vec<TaskGroupStep>,
6381 #[serde(default, skip_serializing_if = "Option::is_none")]
6382 pub version: Option<TaskVersion>,
6383}
6384impl TaskGroupUpdateParameter {
6385 pub fn new() -> Self {
6386 Self::default()
6387 }
6388}
6389#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6390pub struct TaskGroupUpdatePropertiesBase {
6391 #[doc = "Comment for this update request"]
6392 #[serde(default, skip_serializing_if = "Option::is_none")]
6393 pub comment: Option<String>,
6394}
6395impl TaskGroupUpdatePropertiesBase {
6396 pub fn new() -> Self {
6397 Self::default()
6398 }
6399}
6400#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6401pub struct TaskHubLicenseDetails {
6402 #[serde(
6403 rename = "enterpriseUsersCount",
6404 default,
6405 skip_serializing_if = "Option::is_none"
6406 )]
6407 pub enterprise_users_count: Option<i32>,
6408 #[serde(
6409 rename = "failedToReachAllProviders",
6410 default,
6411 skip_serializing_if = "Option::is_none"
6412 )]
6413 pub failed_to_reach_all_providers: Option<bool>,
6414 #[serde(
6415 rename = "freeHostedLicenseCount",
6416 default,
6417 skip_serializing_if = "Option::is_none"
6418 )]
6419 pub free_hosted_license_count: Option<i32>,
6420 #[serde(
6421 rename = "freeLicenseCount",
6422 default,
6423 skip_serializing_if = "Option::is_none"
6424 )]
6425 pub free_license_count: Option<i32>,
6426 #[serde(
6427 rename = "hasLicenseCountEverUpdated",
6428 default,
6429 skip_serializing_if = "Option::is_none"
6430 )]
6431 pub has_license_count_ever_updated: Option<bool>,
6432 #[serde(
6433 rename = "hostedAgentMinutesFreeCount",
6434 default,
6435 skip_serializing_if = "Option::is_none"
6436 )]
6437 pub hosted_agent_minutes_free_count: Option<i32>,
6438 #[serde(
6439 rename = "hostedAgentMinutesUsedCount",
6440 default,
6441 skip_serializing_if = "Option::is_none"
6442 )]
6443 pub hosted_agent_minutes_used_count: Option<i32>,
6444 #[serde(
6445 rename = "hostedLicensesArePremium",
6446 default,
6447 skip_serializing_if = "Option::is_none"
6448 )]
6449 pub hosted_licenses_are_premium: Option<bool>,
6450 #[serde(
6451 rename = "msdnUsersCount",
6452 default,
6453 skip_serializing_if = "Option::is_none"
6454 )]
6455 pub msdn_users_count: Option<i32>,
6456 #[doc = "Microsoft-hosted licenses purchased from VSTS directly."]
6457 #[serde(
6458 rename = "purchasedHostedLicenseCount",
6459 default,
6460 skip_serializing_if = "Option::is_none"
6461 )]
6462 pub purchased_hosted_license_count: Option<i32>,
6463 #[doc = "Self-hosted licenses purchased from VSTS directly."]
6464 #[serde(
6465 rename = "purchasedLicenseCount",
6466 default,
6467 skip_serializing_if = "Option::is_none"
6468 )]
6469 pub purchased_license_count: Option<i32>,
6470 #[serde(
6471 rename = "totalHostedLicenseCount",
6472 default,
6473 skip_serializing_if = "Option::is_none"
6474 )]
6475 pub total_hosted_license_count: Option<i32>,
6476 #[serde(
6477 rename = "totalLicenseCount",
6478 default,
6479 skip_serializing_if = "Option::is_none"
6480 )]
6481 pub total_license_count: Option<i32>,
6482 #[serde(
6483 rename = "totalPrivateLicenseCount",
6484 default,
6485 skip_serializing_if = "Option::is_none"
6486 )]
6487 pub total_private_license_count: Option<i32>,
6488}
6489impl TaskHubLicenseDetails {
6490 pub fn new() -> Self {
6491 Self::default()
6492 }
6493}
6494#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6495pub struct TaskHubOidcToken {
6496 #[serde(rename = "oidcToken", default, skip_serializing_if = "Option::is_none")]
6497 pub oidc_token: Option<String>,
6498}
6499impl TaskHubOidcToken {
6500 pub fn new() -> Self {
6501 Self::default()
6502 }
6503}
6504#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6505pub struct TaskInputDefinition {
6506 #[serde(flatten)]
6507 pub task_input_definition_base: TaskInputDefinitionBase,
6508}
6509impl TaskInputDefinition {
6510 pub fn new() -> Self {
6511 Self::default()
6512 }
6513}
6514#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6515pub struct TaskInputDefinitionBase {
6516 #[serde(
6517 default,
6518 deserialize_with = "crate::serde::deserialize_null_as_default",
6519 skip_serializing_if = "Vec::is_empty"
6520 )]
6521 pub aliases: Vec<String>,
6522 #[serde(
6523 rename = "defaultValue",
6524 default,
6525 skip_serializing_if = "Option::is_none"
6526 )]
6527 pub default_value: Option<String>,
6528 #[serde(rename = "groupName", default, skip_serializing_if = "Option::is_none")]
6529 pub group_name: Option<String>,
6530 #[serde(
6531 rename = "helpMarkDown",
6532 default,
6533 skip_serializing_if = "Option::is_none"
6534 )]
6535 pub help_mark_down: Option<String>,
6536 #[serde(default, skip_serializing_if = "Option::is_none")]
6537 pub label: Option<String>,
6538 #[serde(default, skip_serializing_if = "Option::is_none")]
6539 pub name: Option<String>,
6540 #[serde(default, skip_serializing_if = "Option::is_none")]
6541 pub options: Option<serde_json::Value>,
6542 #[serde(default, skip_serializing_if = "Option::is_none")]
6543 pub properties: Option<serde_json::Value>,
6544 #[serde(default, skip_serializing_if = "Option::is_none")]
6545 pub required: Option<bool>,
6546 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
6547 pub type_: Option<String>,
6548 #[serde(default, skip_serializing_if = "Option::is_none")]
6549 pub validation: Option<TaskInputValidation>,
6550 #[serde(
6551 rename = "visibleRule",
6552 default,
6553 skip_serializing_if = "Option::is_none"
6554 )]
6555 pub visible_rule: Option<String>,
6556}
6557impl TaskInputDefinitionBase {
6558 pub fn new() -> Self {
6559 Self::default()
6560 }
6561}
6562#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6563pub struct TaskInputValidation {
6564 #[doc = "Conditional expression"]
6565 #[serde(default, skip_serializing_if = "Option::is_none")]
6566 pub expression: Option<String>,
6567 #[doc = "Message explaining how user can correct if validation fails"]
6568 #[serde(default, skip_serializing_if = "Option::is_none")]
6569 pub message: Option<String>,
6570}
6571impl TaskInputValidation {
6572 pub fn new() -> Self {
6573 Self::default()
6574 }
6575}
6576#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6577pub struct TaskInstance {
6578 #[serde(flatten)]
6579 pub task_reference: TaskReference,
6580 #[serde(rename = "alwaysRun", default, skip_serializing_if = "Option::is_none")]
6581 pub always_run: Option<bool>,
6582 #[serde(default, skip_serializing_if = "Option::is_none")]
6583 pub condition: Option<String>,
6584 #[serde(
6585 rename = "continueOnError",
6586 default,
6587 skip_serializing_if = "Option::is_none"
6588 )]
6589 pub continue_on_error: Option<bool>,
6590 #[serde(
6591 rename = "displayName",
6592 default,
6593 skip_serializing_if = "Option::is_none"
6594 )]
6595 pub display_name: Option<String>,
6596 #[serde(default, skip_serializing_if = "Option::is_none")]
6597 pub enabled: Option<bool>,
6598 #[serde(default, skip_serializing_if = "Option::is_none")]
6599 pub environment: Option<serde_json::Value>,
6600 #[serde(
6601 rename = "instanceId",
6602 default,
6603 skip_serializing_if = "Option::is_none"
6604 )]
6605 pub instance_id: Option<String>,
6606 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
6607 pub ref_name: Option<String>,
6608 #[serde(
6609 rename = "retryCountOnTaskFailure",
6610 default,
6611 skip_serializing_if = "Option::is_none"
6612 )]
6613 pub retry_count_on_task_failure: Option<i32>,
6614 #[serde(
6615 rename = "timeoutInMinutes",
6616 default,
6617 skip_serializing_if = "Option::is_none"
6618 )]
6619 pub timeout_in_minutes: Option<i32>,
6620}
6621impl TaskInstance {
6622 pub fn new() -> Self {
6623 Self::default()
6624 }
6625}
6626#[doc = "A task log connected to a timeline record."]
6627#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6628pub struct TaskLog {
6629 #[serde(flatten)]
6630 pub task_log_reference: TaskLogReference,
6631 #[doc = "The time of the task log creation."]
6632 #[serde(
6633 rename = "createdOn",
6634 default,
6635 skip_serializing_if = "Option::is_none",
6636 with = "crate::date_time::rfc3339::option"
6637 )]
6638 pub created_on: Option<time::OffsetDateTime>,
6639 #[doc = "The REST URL of the task log when indexed."]
6640 #[serde(
6641 rename = "indexLocation",
6642 default,
6643 skip_serializing_if = "Option::is_none"
6644 )]
6645 pub index_location: Option<String>,
6646 #[doc = "The time of the last modification of the task log."]
6647 #[serde(
6648 rename = "lastChangedOn",
6649 default,
6650 skip_serializing_if = "Option::is_none",
6651 with = "crate::date_time::rfc3339::option"
6652 )]
6653 pub last_changed_on: Option<time::OffsetDateTime>,
6654 #[doc = "The number of the task log lines."]
6655 #[serde(rename = "lineCount", default, skip_serializing_if = "Option::is_none")]
6656 pub line_count: Option<i64>,
6657 #[doc = "The path of the task log."]
6658 #[serde(default, skip_serializing_if = "Option::is_none")]
6659 pub path: Option<String>,
6660}
6661impl TaskLog {
6662 pub fn new() -> Self {
6663 Self::default()
6664 }
6665}
6666#[doc = "A reference to a task log. This class contains information about the output printed to the timeline record's logs console during pipeline run."]
6667#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6668pub struct TaskLogReference {
6669 #[doc = "The ID of the task log."]
6670 #[serde(default, skip_serializing_if = "Option::is_none")]
6671 pub id: Option<i32>,
6672 #[doc = "The REST URL of the task log."]
6673 #[serde(default, skip_serializing_if = "Option::is_none")]
6674 pub location: Option<String>,
6675}
6676impl TaskLogReference {
6677 pub fn new() -> Self {
6678 Self::default()
6679 }
6680}
6681#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6682pub struct TaskOrchestrationContainer {
6683 #[serde(flatten)]
6684 pub task_orchestration_item: TaskOrchestrationItem,
6685 #[serde(
6686 default,
6687 deserialize_with = "crate::serde::deserialize_null_as_default",
6688 skip_serializing_if = "Vec::is_empty"
6689 )]
6690 pub children: Vec<TaskOrchestrationItem>,
6691 #[serde(
6692 rename = "continueOnError",
6693 default,
6694 skip_serializing_if = "Option::is_none"
6695 )]
6696 pub continue_on_error: Option<bool>,
6697 #[serde(default, skip_serializing_if = "Option::is_none")]
6698 pub data: Option<serde_json::Value>,
6699 #[serde(
6700 rename = "maxConcurrency",
6701 default,
6702 skip_serializing_if = "Option::is_none"
6703 )]
6704 pub max_concurrency: Option<i32>,
6705 #[serde(default, skip_serializing_if = "Option::is_none")]
6706 pub parallel: Option<bool>,
6707 #[serde(default, skip_serializing_if = "Option::is_none")]
6708 pub rollback: Option<Box<TaskOrchestrationContainer>>,
6709}
6710impl TaskOrchestrationContainer {
6711 pub fn new() -> Self {
6712 Self::default()
6713 }
6714}
6715#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6716pub struct TaskOrchestrationItem {
6717 #[serde(rename = "itemType", default, skip_serializing_if = "Option::is_none")]
6718 pub item_type: Option<task_orchestration_item::ItemType>,
6719}
6720impl TaskOrchestrationItem {
6721 pub fn new() -> Self {
6722 Self::default()
6723 }
6724}
6725pub mod task_orchestration_item {
6726 use super::*;
6727 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
6728 pub enum ItemType {
6729 #[serde(rename = "container")]
6730 Container,
6731 #[serde(rename = "job")]
6732 Job,
6733 }
6734}
6735#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6736pub struct TaskOrchestrationJob {
6737 #[serde(flatten)]
6738 pub task_orchestration_item: TaskOrchestrationItem,
6739 #[serde(
6740 default,
6741 deserialize_with = "crate::serde::deserialize_null_as_default",
6742 skip_serializing_if = "Vec::is_empty"
6743 )]
6744 pub demands: Vec<Demand>,
6745 #[serde(rename = "executeAs", default, skip_serializing_if = "Option::is_none")]
6746 pub execute_as: Option<IdentityRef>,
6747 #[serde(
6748 rename = "executionMode",
6749 default,
6750 skip_serializing_if = "Option::is_none"
6751 )]
6752 pub execution_mode: Option<String>,
6753 #[serde(
6754 rename = "executionTimeout",
6755 default,
6756 skip_serializing_if = "Option::is_none"
6757 )]
6758 pub execution_timeout: Option<String>,
6759 #[serde(
6760 rename = "instanceId",
6761 default,
6762 skip_serializing_if = "Option::is_none"
6763 )]
6764 pub instance_id: Option<String>,
6765 #[serde(default, skip_serializing_if = "Option::is_none")]
6766 pub name: Option<String>,
6767 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
6768 pub ref_name: Option<String>,
6769 #[serde(
6770 default,
6771 deserialize_with = "crate::serde::deserialize_null_as_default",
6772 skip_serializing_if = "Vec::is_empty"
6773 )]
6774 pub tasks: Vec<TaskInstance>,
6775 #[serde(default, skip_serializing_if = "Option::is_none")]
6776 pub variables: Option<serde_json::Value>,
6777}
6778impl TaskOrchestrationJob {
6779 pub fn new() -> Self {
6780 Self::default()
6781 }
6782}
6783#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6784pub struct TaskOrchestrationOwner {
6785 #[doc = "The class to represent a collection of REST reference links."]
6786 #[serde(rename = "_links", default, skip_serializing_if = "Option::is_none")]
6787 pub links: Option<ReferenceLinks>,
6788 #[serde(default, skip_serializing_if = "Option::is_none")]
6789 pub id: Option<i32>,
6790 #[serde(default, skip_serializing_if = "Option::is_none")]
6791 pub name: Option<String>,
6792}
6793impl TaskOrchestrationOwner {
6794 pub fn new() -> Self {
6795 Self::default()
6796 }
6797}
6798#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6799pub struct TaskOrchestrationPlan {
6800 #[serde(flatten)]
6801 pub task_orchestration_plan_reference: TaskOrchestrationPlanReference,
6802 #[serde(default, skip_serializing_if = "Option::is_none")]
6803 pub environment: Option<PlanEnvironment>,
6804 #[doc = "A reference to a task log. This class contains information about the output printed to the timeline record's logs console during pipeline run."]
6805 #[serde(
6806 rename = "expandedYaml",
6807 default,
6808 skip_serializing_if = "Option::is_none"
6809 )]
6810 pub expanded_yaml: Option<TaskLogReference>,
6811 #[serde(
6812 rename = "finishTime",
6813 default,
6814 skip_serializing_if = "Option::is_none",
6815 with = "crate::date_time::rfc3339::option"
6816 )]
6817 pub finish_time: Option<time::OffsetDateTime>,
6818 #[serde(default, skip_serializing_if = "Option::is_none")]
6819 pub implementation: Option<TaskOrchestrationContainer>,
6820 #[doc = "A reference to a task log. This class contains information about the output printed to the timeline record's logs console during pipeline run."]
6821 #[serde(
6822 rename = "initializationLog",
6823 default,
6824 skip_serializing_if = "Option::is_none"
6825 )]
6826 pub initialization_log: Option<TaskLogReference>,
6827 #[serde(
6828 rename = "requestedById",
6829 default,
6830 skip_serializing_if = "Option::is_none"
6831 )]
6832 pub requested_by_id: Option<String>,
6833 #[serde(
6834 rename = "requestedForId",
6835 default,
6836 skip_serializing_if = "Option::is_none"
6837 )]
6838 pub requested_for_id: Option<String>,
6839 #[serde(default, skip_serializing_if = "Option::is_none")]
6840 pub result: Option<task_orchestration_plan::Result>,
6841 #[serde(
6842 rename = "resultCode",
6843 default,
6844 skip_serializing_if = "Option::is_none"
6845 )]
6846 pub result_code: Option<String>,
6847 #[serde(
6848 rename = "startTime",
6849 default,
6850 skip_serializing_if = "Option::is_none",
6851 with = "crate::date_time::rfc3339::option"
6852 )]
6853 pub start_time: Option<time::OffsetDateTime>,
6854 #[serde(default, skip_serializing_if = "Option::is_none")]
6855 pub state: Option<task_orchestration_plan::State>,
6856 #[doc = "A reference to a timeline."]
6857 #[serde(default, skip_serializing_if = "Option::is_none")]
6858 pub timeline: Option<TimelineReference>,
6859}
6860impl TaskOrchestrationPlan {
6861 pub fn new() -> Self {
6862 Self::default()
6863 }
6864}
6865pub mod task_orchestration_plan {
6866 use super::*;
6867 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
6868 pub enum Result {
6869 #[serde(rename = "succeeded")]
6870 Succeeded,
6871 #[serde(rename = "succeededWithIssues")]
6872 SucceededWithIssues,
6873 #[serde(rename = "failed")]
6874 Failed,
6875 #[serde(rename = "canceled")]
6876 Canceled,
6877 #[serde(rename = "skipped")]
6878 Skipped,
6879 #[serde(rename = "abandoned")]
6880 Abandoned,
6881 }
6882 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
6883 pub enum State {
6884 #[serde(rename = "inProgress")]
6885 InProgress,
6886 #[serde(rename = "queued")]
6887 Queued,
6888 #[serde(rename = "completed")]
6889 Completed,
6890 #[serde(rename = "throttled")]
6891 Throttled,
6892 }
6893}
6894#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6895pub struct TaskOrchestrationPlanGroup {
6896 #[serde(rename = "planGroup", default, skip_serializing_if = "Option::is_none")]
6897 pub plan_group: Option<String>,
6898 #[serde(default, skip_serializing_if = "Option::is_none")]
6899 pub project: Option<ProjectReference>,
6900 #[serde(
6901 rename = "runningRequests",
6902 default,
6903 deserialize_with = "crate::serde::deserialize_null_as_default",
6904 skip_serializing_if = "Vec::is_empty"
6905 )]
6906 pub running_requests: Vec<TaskAgentJobRequest>,
6907}
6908impl TaskOrchestrationPlanGroup {
6909 pub fn new() -> Self {
6910 Self::default()
6911 }
6912}
6913#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6914pub struct TaskOrchestrationPlanGroupsQueueMetrics {
6915 #[serde(default, skip_serializing_if = "Option::is_none")]
6916 pub count: Option<i32>,
6917 #[serde(default, skip_serializing_if = "Option::is_none")]
6918 pub status: Option<task_orchestration_plan_groups_queue_metrics::Status>,
6919}
6920impl TaskOrchestrationPlanGroupsQueueMetrics {
6921 pub fn new() -> Self {
6922 Self::default()
6923 }
6924}
6925pub mod task_orchestration_plan_groups_queue_metrics {
6926 use super::*;
6927 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
6928 pub enum Status {
6929 #[serde(rename = "running")]
6930 Running,
6931 #[serde(rename = "queued")]
6932 Queued,
6933 #[serde(rename = "all")]
6934 All,
6935 }
6936}
6937#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6938pub struct TaskOrchestrationPlanReference {
6939 #[serde(
6940 rename = "artifactLocation",
6941 default,
6942 skip_serializing_if = "Option::is_none"
6943 )]
6944 pub artifact_location: Option<String>,
6945 #[serde(
6946 rename = "artifactUri",
6947 default,
6948 skip_serializing_if = "Option::is_none"
6949 )]
6950 pub artifact_uri: Option<String>,
6951 #[serde(default, skip_serializing_if = "Option::is_none")]
6952 pub definition: Option<TaskOrchestrationOwner>,
6953 #[serde(default, skip_serializing_if = "Option::is_none")]
6954 pub owner: Option<TaskOrchestrationOwner>,
6955 #[serde(rename = "planGroup", default, skip_serializing_if = "Option::is_none")]
6956 pub plan_group: Option<String>,
6957 #[serde(rename = "planId", default, skip_serializing_if = "Option::is_none")]
6958 pub plan_id: Option<String>,
6959 #[serde(rename = "planType", default, skip_serializing_if = "Option::is_none")]
6960 pub plan_type: Option<String>,
6961 #[serde(
6962 rename = "scopeIdentifier",
6963 default,
6964 skip_serializing_if = "Option::is_none"
6965 )]
6966 pub scope_identifier: Option<String>,
6967 #[serde(default, skip_serializing_if = "Option::is_none")]
6968 pub version: Option<i32>,
6969}
6970impl TaskOrchestrationPlanReference {
6971 pub fn new() -> Self {
6972 Self::default()
6973 }
6974}
6975#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
6976pub struct TaskOrchestrationQueuedPlan {
6977 #[serde(
6978 rename = "assignTime",
6979 default,
6980 skip_serializing_if = "Option::is_none",
6981 with = "crate::date_time::rfc3339::option"
6982 )]
6983 pub assign_time: Option<time::OffsetDateTime>,
6984 #[serde(default, skip_serializing_if = "Option::is_none")]
6985 pub definition: Option<TaskOrchestrationOwner>,
6986 #[serde(default, skip_serializing_if = "Option::is_none")]
6987 pub owner: Option<TaskOrchestrationOwner>,
6988 #[serde(rename = "planGroup", default, skip_serializing_if = "Option::is_none")]
6989 pub plan_group: Option<String>,
6990 #[serde(rename = "planId", default, skip_serializing_if = "Option::is_none")]
6991 pub plan_id: Option<String>,
6992 #[serde(rename = "poolId", default, skip_serializing_if = "Option::is_none")]
6993 pub pool_id: Option<i32>,
6994 #[serde(
6995 rename = "queuePosition",
6996 default,
6997 skip_serializing_if = "Option::is_none"
6998 )]
6999 pub queue_position: Option<i32>,
7000 #[serde(
7001 rename = "queueTime",
7002 default,
7003 skip_serializing_if = "Option::is_none",
7004 with = "crate::date_time::rfc3339::option"
7005 )]
7006 pub queue_time: Option<time::OffsetDateTime>,
7007 #[serde(
7008 rename = "scopeIdentifier",
7009 default,
7010 skip_serializing_if = "Option::is_none"
7011 )]
7012 pub scope_identifier: Option<String>,
7013}
7014impl TaskOrchestrationQueuedPlan {
7015 pub fn new() -> Self {
7016 Self::default()
7017 }
7018}
7019#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7020pub struct TaskOrchestrationQueuedPlanGroup {
7021 #[serde(default, skip_serializing_if = "Option::is_none")]
7022 pub definition: Option<TaskOrchestrationOwner>,
7023 #[serde(default, skip_serializing_if = "Option::is_none")]
7024 pub owner: Option<TaskOrchestrationOwner>,
7025 #[serde(rename = "planGroup", default, skip_serializing_if = "Option::is_none")]
7026 pub plan_group: Option<String>,
7027 #[serde(
7028 default,
7029 deserialize_with = "crate::serde::deserialize_null_as_default",
7030 skip_serializing_if = "Vec::is_empty"
7031 )]
7032 pub plans: Vec<TaskOrchestrationQueuedPlan>,
7033 #[serde(default, skip_serializing_if = "Option::is_none")]
7034 pub project: Option<ProjectReference>,
7035 #[serde(
7036 rename = "queuePosition",
7037 default,
7038 skip_serializing_if = "Option::is_none"
7039 )]
7040 pub queue_position: Option<i32>,
7041}
7042impl TaskOrchestrationQueuedPlanGroup {
7043 pub fn new() -> Self {
7044 Self::default()
7045 }
7046}
7047#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7048pub struct TaskOutputVariable {
7049 #[serde(default, skip_serializing_if = "Option::is_none")]
7050 pub description: Option<String>,
7051 #[serde(default, skip_serializing_if = "Option::is_none")]
7052 pub name: Option<String>,
7053}
7054impl TaskOutputVariable {
7055 pub fn new() -> Self {
7056 Self::default()
7057 }
7058}
7059#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7060pub struct TaskPackageMetadata {
7061 #[doc = "Gets the name of the package."]
7062 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
7063 pub type_: Option<String>,
7064 #[doc = "Gets the url of the package."]
7065 #[serde(default, skip_serializing_if = "Option::is_none")]
7066 pub url: Option<String>,
7067 #[doc = "Gets the version of the package."]
7068 #[serde(default, skip_serializing_if = "Option::is_none")]
7069 pub version: Option<String>,
7070}
7071impl TaskPackageMetadata {
7072 pub fn new() -> Self {
7073 Self::default()
7074 }
7075}
7076#[doc = "A reference to a task."]
7077#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7078pub struct TaskReference {
7079 #[doc = "The ID of the task definition. Corresponds to the id value of task.json file. <br />Example: CmdLineV2 { \"id\": \"D9BAFED4-0B18-4F58-968D-86655B4D2CE9\" }"]
7080 #[serde(default, skip_serializing_if = "Option::is_none")]
7081 pub id: Option<String>,
7082 #[doc = "A dictionary of inputs specific to a task definition. Corresponds to inputs value of task.json file."]
7083 #[serde(default, skip_serializing_if = "Option::is_none")]
7084 pub inputs: Option<serde_json::Value>,
7085 #[doc = "The name of the task definition. Corresponds to the name value of task.json file. <br />Example: CmdLineV2 { \"name\": \"CmdLine\" }"]
7086 #[serde(default, skip_serializing_if = "Option::is_none")]
7087 pub name: Option<String>,
7088 #[doc = "The version of the task definition. Corresponds to the version value of task.json file. <br />Example: CmdLineV2 { \"version\": { \"Major\": 2, \"Minor\": 212, \"Patch\": 0 } }"]
7089 #[serde(default, skip_serializing_if = "Option::is_none")]
7090 pub version: Option<String>,
7091}
7092impl TaskReference {
7093 pub fn new() -> Self {
7094 Self::default()
7095 }
7096}
7097#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7098pub struct TaskRestrictions {
7099 #[serde(default, skip_serializing_if = "Option::is_none")]
7100 pub commands: Option<TaskCommandRestrictions>,
7101 #[serde(
7102 rename = "settableVariables",
7103 default,
7104 skip_serializing_if = "Option::is_none"
7105 )]
7106 pub settable_variables: Option<TaskVariableRestrictions>,
7107}
7108impl TaskRestrictions {
7109 pub fn new() -> Self {
7110 Self::default()
7111 }
7112}
7113#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7114pub struct TaskSourceDefinition {
7115 #[serde(flatten)]
7116 pub task_source_definition_base: TaskSourceDefinitionBase,
7117}
7118impl TaskSourceDefinition {
7119 pub fn new() -> Self {
7120 Self::default()
7121 }
7122}
7123#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7124pub struct TaskSourceDefinitionBase {
7125 #[serde(rename = "authKey", default, skip_serializing_if = "Option::is_none")]
7126 pub auth_key: Option<String>,
7127 #[serde(default, skip_serializing_if = "Option::is_none")]
7128 pub endpoint: Option<String>,
7129 #[serde(
7130 rename = "keySelector",
7131 default,
7132 skip_serializing_if = "Option::is_none"
7133 )]
7134 pub key_selector: Option<String>,
7135 #[serde(default, skip_serializing_if = "Option::is_none")]
7136 pub selector: Option<String>,
7137 #[serde(default, skip_serializing_if = "Option::is_none")]
7138 pub target: Option<String>,
7139}
7140impl TaskSourceDefinitionBase {
7141 pub fn new() -> Self {
7142 Self::default()
7143 }
7144}
7145#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7146pub struct TaskStartedEvent {
7147 #[serde(flatten)]
7148 pub task_event: TaskEvent,
7149}
7150impl TaskStartedEvent {
7151 pub fn new() -> Self {
7152 Self::default()
7153 }
7154}
7155#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7156pub struct TaskVariableRestrictions {
7157 #[serde(
7158 default,
7159 deserialize_with = "crate::serde::deserialize_null_as_default",
7160 skip_serializing_if = "Vec::is_empty"
7161 )]
7162 pub allowed: Vec<String>,
7163}
7164impl TaskVariableRestrictions {
7165 pub fn new() -> Self {
7166 Self::default()
7167 }
7168}
7169#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7170pub struct TaskVersion {
7171 #[serde(rename = "isTest", default, skip_serializing_if = "Option::is_none")]
7172 pub is_test: Option<bool>,
7173 #[serde(default, skip_serializing_if = "Option::is_none")]
7174 pub major: Option<i32>,
7175 #[serde(default, skip_serializing_if = "Option::is_none")]
7176 pub minor: Option<i32>,
7177 #[serde(default, skip_serializing_if = "Option::is_none")]
7178 pub patch: Option<i32>,
7179}
7180impl TaskVersion {
7181 pub fn new() -> Self {
7182 Self::default()
7183 }
7184}
7185#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7186pub struct Timeline {
7187 #[serde(flatten)]
7188 pub timeline_reference: TimelineReference,
7189 #[serde(
7190 rename = "lastChangedBy",
7191 default,
7192 skip_serializing_if = "Option::is_none"
7193 )]
7194 pub last_changed_by: Option<String>,
7195 #[serde(
7196 rename = "lastChangedOn",
7197 default,
7198 skip_serializing_if = "Option::is_none",
7199 with = "crate::date_time::rfc3339::option"
7200 )]
7201 pub last_changed_on: Option<time::OffsetDateTime>,
7202 #[serde(
7203 default,
7204 deserialize_with = "crate::serde::deserialize_null_as_default",
7205 skip_serializing_if = "Vec::is_empty"
7206 )]
7207 pub records: Vec<TimelineRecord>,
7208}
7209impl Timeline {
7210 pub fn new() -> Self {
7211 Self::default()
7212 }
7213}
7214#[doc = "An attempt to update a TimelineRecord."]
7215#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7216pub struct TimelineAttempt {
7217 #[doc = "The attempt of the record."]
7218 #[serde(default, skip_serializing_if = "Option::is_none")]
7219 pub attempt: Option<i32>,
7220 #[doc = "The unique identifier for the record."]
7221 #[serde(default, skip_serializing_if = "Option::is_none")]
7222 pub identifier: Option<String>,
7223 #[doc = "The record identifier located within the specified timeline."]
7224 #[serde(rename = "recordId", default, skip_serializing_if = "Option::is_none")]
7225 pub record_id: Option<String>,
7226 #[doc = "The timeline identifier which owns the record representing this attempt."]
7227 #[serde(
7228 rename = "timelineId",
7229 default,
7230 skip_serializing_if = "Option::is_none"
7231 )]
7232 pub timeline_id: Option<String>,
7233}
7234impl TimelineAttempt {
7235 pub fn new() -> Self {
7236 Self::default()
7237 }
7238}
7239#[doc = "Detailed information about the execution of different operations during pipeline run."]
7240#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7241pub struct TimelineRecord {
7242 #[doc = "The specification of an agent running a pipeline job, in binary format. Applicable when record is of type Job. <br />Example: { \"VMImage\" : \"windows-2019\" }"]
7243 #[serde(
7244 rename = "agentSpecification",
7245 default,
7246 skip_serializing_if = "Option::is_none"
7247 )]
7248 pub agent_specification: Option<serde_json::Value>,
7249 #[doc = "The number of record attempts."]
7250 #[serde(default, skip_serializing_if = "Option::is_none")]
7251 pub attempt: Option<i32>,
7252 #[doc = "The ID connecting all records updated at the same time. This value is taken from timeline's ChangeId."]
7253 #[serde(rename = "changeId", default, skip_serializing_if = "Option::is_none")]
7254 pub change_id: Option<i32>,
7255 #[doc = "A string that indicates the current operation."]
7256 #[serde(
7257 rename = "currentOperation",
7258 default,
7259 skip_serializing_if = "Option::is_none"
7260 )]
7261 pub current_operation: Option<String>,
7262 #[doc = "A reference to a timeline."]
7263 #[serde(default, skip_serializing_if = "Option::is_none")]
7264 pub details: Option<TimelineReference>,
7265 #[doc = "The number of errors produced by this operation."]
7266 #[serde(
7267 rename = "errorCount",
7268 default,
7269 skip_serializing_if = "Option::is_none"
7270 )]
7271 pub error_count: Option<i32>,
7272 #[doc = "The finish time of the record."]
7273 #[serde(
7274 rename = "finishTime",
7275 default,
7276 skip_serializing_if = "Option::is_none",
7277 with = "crate::date_time::rfc3339::option"
7278 )]
7279 pub finish_time: Option<time::OffsetDateTime>,
7280 #[doc = "The ID of the record."]
7281 #[serde(default, skip_serializing_if = "Option::is_none")]
7282 pub id: Option<String>,
7283 #[doc = "String identifier that is consistent across attempts."]
7284 #[serde(default, skip_serializing_if = "Option::is_none")]
7285 pub identifier: Option<String>,
7286 #[doc = "The list of issues produced by this operation."]
7287 #[serde(
7288 default,
7289 deserialize_with = "crate::serde::deserialize_null_as_default",
7290 skip_serializing_if = "Vec::is_empty"
7291 )]
7292 pub issues: Vec<Issue>,
7293 #[doc = "The time the record was last modified."]
7294 #[serde(
7295 rename = "lastModified",
7296 default,
7297 skip_serializing_if = "Option::is_none",
7298 with = "crate::date_time::rfc3339::option"
7299 )]
7300 pub last_modified: Option<time::OffsetDateTime>,
7301 #[doc = "The REST URL of the record."]
7302 #[serde(default, skip_serializing_if = "Option::is_none")]
7303 pub location: Option<String>,
7304 #[doc = "A reference to a task log. This class contains information about the output printed to the timeline record's logs console during pipeline run."]
7305 #[serde(default, skip_serializing_if = "Option::is_none")]
7306 pub log: Option<TaskLogReference>,
7307 #[doc = "The name of the record."]
7308 #[serde(default, skip_serializing_if = "Option::is_none")]
7309 pub name: Option<String>,
7310 #[doc = "An ordinal value relative to other records within the timeline."]
7311 #[serde(default, skip_serializing_if = "Option::is_none")]
7312 pub order: Option<i32>,
7313 #[doc = "The ID of the record's parent. <br />Example: Stage is a parent of a Phase, Phase is a parent of a Job, Job is a parent of a Task."]
7314 #[serde(rename = "parentId", default, skip_serializing_if = "Option::is_none")]
7315 pub parent_id: Option<String>,
7316 #[doc = "The percentage of record completion."]
7317 #[serde(
7318 rename = "percentComplete",
7319 default,
7320 skip_serializing_if = "Option::is_none"
7321 )]
7322 pub percent_complete: Option<i32>,
7323 #[doc = "The previous record attempts."]
7324 #[serde(
7325 rename = "previousAttempts",
7326 default,
7327 deserialize_with = "crate::serde::deserialize_null_as_default",
7328 skip_serializing_if = "Vec::is_empty"
7329 )]
7330 pub previous_attempts: Vec<TimelineAttempt>,
7331 #[doc = "The ID of the queue which connects projects to agent pools on which the operation ran on. Applicable when record is of type Job."]
7332 #[serde(rename = "queueId", default, skip_serializing_if = "Option::is_none")]
7333 pub queue_id: Option<i32>,
7334 #[doc = "Name of the referenced record."]
7335 #[serde(rename = "refName", default, skip_serializing_if = "Option::is_none")]
7336 pub ref_name: Option<String>,
7337 #[doc = "The result of the record."]
7338 #[serde(default, skip_serializing_if = "Option::is_none")]
7339 pub result: Option<timeline_record::Result>,
7340 #[doc = "Evaluation of predefined conditions upon completion of record's operation. <br />Example: Evaluating `succeeded()`, Result = True <br />Example: Evaluating `and(succeeded(), eq(variables['system.debug'], False))`, Result = False"]
7341 #[serde(
7342 rename = "resultCode",
7343 default,
7344 skip_serializing_if = "Option::is_none"
7345 )]
7346 pub result_code: Option<String>,
7347 #[doc = "The start time of the record."]
7348 #[serde(
7349 rename = "startTime",
7350 default,
7351 skip_serializing_if = "Option::is_none",
7352 with = "crate::date_time::rfc3339::option"
7353 )]
7354 pub start_time: Option<time::OffsetDateTime>,
7355 #[doc = "The state of the record."]
7356 #[serde(default, skip_serializing_if = "Option::is_none")]
7357 pub state: Option<timeline_record::State>,
7358 #[doc = "A reference to a task."]
7359 #[serde(default, skip_serializing_if = "Option::is_none")]
7360 pub task: Option<TaskReference>,
7361 #[doc = "The type of operation being tracked by the record. <br />Example: Stage, Phase, Job, Task..."]
7362 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
7363 pub type_: Option<String>,
7364 #[doc = "The variables of the record."]
7365 #[serde(default, skip_serializing_if = "Option::is_none")]
7366 pub variables: Option<serde_json::Value>,
7367 #[doc = "The number of warnings produced by this operation."]
7368 #[serde(
7369 rename = "warningCount",
7370 default,
7371 skip_serializing_if = "Option::is_none"
7372 )]
7373 pub warning_count: Option<i32>,
7374 #[doc = "The name of the agent running the operation. Applicable when record is of type Job."]
7375 #[serde(
7376 rename = "workerName",
7377 default,
7378 skip_serializing_if = "Option::is_none"
7379 )]
7380 pub worker_name: Option<String>,
7381}
7382impl TimelineRecord {
7383 pub fn new() -> Self {
7384 Self::default()
7385 }
7386}
7387pub mod timeline_record {
7388 use super::*;
7389 #[doc = "The result of the record."]
7390 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
7391 pub enum Result {
7392 #[serde(rename = "succeeded")]
7393 Succeeded,
7394 #[serde(rename = "succeededWithIssues")]
7395 SucceededWithIssues,
7396 #[serde(rename = "failed")]
7397 Failed,
7398 #[serde(rename = "canceled")]
7399 Canceled,
7400 #[serde(rename = "skipped")]
7401 Skipped,
7402 #[serde(rename = "abandoned")]
7403 Abandoned,
7404 }
7405 #[doc = "The state of the record."]
7406 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
7407 pub enum State {
7408 #[serde(rename = "pending")]
7409 Pending,
7410 #[serde(rename = "inProgress")]
7411 InProgress,
7412 #[serde(rename = "completed")]
7413 Completed,
7414 }
7415}
7416#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7417pub struct TimelineRecordFeedLinesWrapper {
7418 #[serde(default, skip_serializing_if = "Option::is_none")]
7419 pub count: Option<i32>,
7420 #[serde(rename = "endLine", default, skip_serializing_if = "Option::is_none")]
7421 pub end_line: Option<i64>,
7422 #[serde(rename = "startLine", default, skip_serializing_if = "Option::is_none")]
7423 pub start_line: Option<i64>,
7424 #[serde(rename = "stepId", default, skip_serializing_if = "Option::is_none")]
7425 pub step_id: Option<String>,
7426 #[serde(
7427 default,
7428 deserialize_with = "crate::serde::deserialize_null_as_default",
7429 skip_serializing_if = "Vec::is_empty"
7430 )]
7431 pub value: Vec<String>,
7432}
7433impl TimelineRecordFeedLinesWrapper {
7434 pub fn new() -> Self {
7435 Self::default()
7436 }
7437}
7438#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7439pub struct TimelineRecordList {
7440 #[serde(default, skip_serializing_if = "Option::is_none")]
7441 pub count: Option<i32>,
7442 #[serde(
7443 default,
7444 deserialize_with = "crate::serde::deserialize_null_as_default",
7445 skip_serializing_if = "Vec::is_empty"
7446 )]
7447 pub value: Vec<TimelineRecord>,
7448}
7449impl TimelineRecordList {
7450 pub fn new() -> Self {
7451 Self::default()
7452 }
7453}
7454#[doc = "A reference to a timeline."]
7455#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7456pub struct TimelineReference {
7457 #[doc = "The change ID."]
7458 #[serde(rename = "changeId", default, skip_serializing_if = "Option::is_none")]
7459 pub change_id: Option<i32>,
7460 #[doc = "The ID of the timeline."]
7461 #[serde(default, skip_serializing_if = "Option::is_none")]
7462 pub id: Option<String>,
7463 #[doc = "The REST URL of the timeline."]
7464 #[serde(default, skip_serializing_if = "Option::is_none")]
7465 pub location: Option<String>,
7466}
7467impl TimelineReference {
7468 pub fn new() -> Self {
7469 Self::default()
7470 }
7471}
7472#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7473pub struct ValidationItem {
7474 #[doc = "Tells whether the current input is valid or not"]
7475 #[serde(rename = "isValid", default, skip_serializing_if = "Option::is_none")]
7476 pub is_valid: Option<bool>,
7477 #[doc = "Reason for input validation failure"]
7478 #[serde(default, skip_serializing_if = "Option::is_none")]
7479 pub reason: Option<String>,
7480 #[doc = "Type of validation item"]
7481 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
7482 pub type_: Option<String>,
7483 #[doc = "Value to validate. The conditional expression to validate for the input for \"expression\" type Eg:eq(variables['Build.SourceBranch'], 'refs/heads/master');eq(value, 'refs/heads/master')"]
7484 #[serde(default, skip_serializing_if = "Option::is_none")]
7485 pub value: Option<String>,
7486}
7487impl ValidationItem {
7488 pub fn new() -> Self {
7489 Self::default()
7490 }
7491}
7492#[doc = "A variable group is a collection of related variables."]
7493#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7494pub struct VariableGroup {
7495 #[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
7496 pub created_by: Option<IdentityRef>,
7497 #[doc = "Gets or sets the time when variable group was created."]
7498 #[serde(
7499 rename = "createdOn",
7500 default,
7501 skip_serializing_if = "Option::is_none",
7502 with = "crate::date_time::rfc3339::option"
7503 )]
7504 pub created_on: Option<time::OffsetDateTime>,
7505 #[doc = "Gets or sets description of the variable group."]
7506 #[serde(default, skip_serializing_if = "Option::is_none")]
7507 pub description: Option<String>,
7508 #[doc = "Gets or sets id of the variable group."]
7509 #[serde(default, skip_serializing_if = "Option::is_none")]
7510 pub id: Option<i32>,
7511 #[doc = "Indicates whether variable group is shared with other projects or not."]
7512 #[serde(rename = "isShared", default, skip_serializing_if = "Option::is_none")]
7513 pub is_shared: Option<bool>,
7514 #[serde(
7515 rename = "modifiedBy",
7516 default,
7517 skip_serializing_if = "Option::is_none"
7518 )]
7519 pub modified_by: Option<IdentityRef>,
7520 #[doc = "Gets or sets the time when variable group was modified"]
7521 #[serde(
7522 rename = "modifiedOn",
7523 default,
7524 skip_serializing_if = "Option::is_none",
7525 with = "crate::date_time::rfc3339::option"
7526 )]
7527 pub modified_on: Option<time::OffsetDateTime>,
7528 #[doc = "Gets or sets name of the variable group."]
7529 #[serde(default, skip_serializing_if = "Option::is_none")]
7530 pub name: Option<String>,
7531 #[doc = "Defines provider data of the variable group."]
7532 #[serde(
7533 rename = "providerData",
7534 default,
7535 skip_serializing_if = "Option::is_none"
7536 )]
7537 pub provider_data: Option<VariableGroupProviderData>,
7538 #[doc = "Gets or sets type of the variable group."]
7539 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
7540 pub type_: Option<String>,
7541 #[doc = "all project references where the variable group is shared with other projects."]
7542 #[serde(
7543 rename = "variableGroupProjectReferences",
7544 default,
7545 deserialize_with = "crate::serde::deserialize_null_as_default",
7546 skip_serializing_if = "Vec::is_empty"
7547 )]
7548 pub variable_group_project_references: Vec<VariableGroupProjectReference>,
7549 #[doc = "Gets or sets variables contained in the variable group."]
7550 #[serde(default, skip_serializing_if = "Option::is_none")]
7551 pub variables: Option<serde_json::Value>,
7552}
7553impl VariableGroup {
7554 pub fn new() -> Self {
7555 Self::default()
7556 }
7557}
7558#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7559pub struct VariableGroupList {
7560 #[serde(default, skip_serializing_if = "Option::is_none")]
7561 pub count: Option<i32>,
7562 #[serde(
7563 default,
7564 deserialize_with = "crate::serde::deserialize_null_as_default",
7565 skip_serializing_if = "Vec::is_empty"
7566 )]
7567 pub value: Vec<VariableGroup>,
7568}
7569impl VariableGroupList {
7570 pub fn new() -> Self {
7571 Self::default()
7572 }
7573}
7574#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7575pub struct VariableGroupParameters {
7576 #[doc = "Sets description of the variable group."]
7577 #[serde(default, skip_serializing_if = "Option::is_none")]
7578 pub description: Option<String>,
7579 #[doc = "Sets name of the variable group."]
7580 #[serde(default, skip_serializing_if = "Option::is_none")]
7581 pub name: Option<String>,
7582 #[doc = "Defines provider data of the variable group."]
7583 #[serde(
7584 rename = "providerData",
7585 default,
7586 skip_serializing_if = "Option::is_none"
7587 )]
7588 pub provider_data: Option<VariableGroupProviderData>,
7589 #[doc = "Sets type of the variable group."]
7590 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
7591 pub type_: Option<String>,
7592 #[serde(
7593 rename = "variableGroupProjectReferences",
7594 default,
7595 deserialize_with = "crate::serde::deserialize_null_as_default",
7596 skip_serializing_if = "Vec::is_empty"
7597 )]
7598 pub variable_group_project_references: Vec<VariableGroupProjectReference>,
7599 #[doc = "Sets variables contained in the variable group."]
7600 #[serde(default, skip_serializing_if = "Option::is_none")]
7601 pub variables: Option<serde_json::Value>,
7602}
7603impl VariableGroupParameters {
7604 pub fn new() -> Self {
7605 Self::default()
7606 }
7607}
7608#[doc = "A variable group reference is a shallow reference to variable group."]
7609#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7610pub struct VariableGroupProjectReference {
7611 #[doc = "Gets or sets description of the variable group."]
7612 #[serde(default, skip_serializing_if = "Option::is_none")]
7613 pub description: Option<String>,
7614 #[doc = "Gets or sets name of the variable group."]
7615 #[serde(default, skip_serializing_if = "Option::is_none")]
7616 pub name: Option<String>,
7617 #[serde(
7618 rename = "projectReference",
7619 default,
7620 skip_serializing_if = "Option::is_none"
7621 )]
7622 pub project_reference: Option<ProjectReference>,
7623}
7624impl VariableGroupProjectReference {
7625 pub fn new() -> Self {
7626 Self::default()
7627 }
7628}
7629#[doc = "Defines provider data of the variable group."]
7630#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7631pub struct VariableGroupProviderData {}
7632impl VariableGroupProviderData {
7633 pub fn new() -> Self {
7634 Self::default()
7635 }
7636}
7637#[doc = "A wrapper class for a generic variable."]
7638#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7639pub struct VariableValue {
7640 #[doc = "Indicates whether the variable can be changed during script's execution runtime."]
7641 #[serde(
7642 rename = "isReadOnly",
7643 default,
7644 skip_serializing_if = "Option::is_none"
7645 )]
7646 pub is_read_only: Option<bool>,
7647 #[doc = "Indicates whether the variable should be encrypted at rest."]
7648 #[serde(rename = "isSecret", default, skip_serializing_if = "Option::is_none")]
7649 pub is_secret: Option<bool>,
7650 #[doc = "The value of the variable."]
7651 #[serde(default, skip_serializing_if = "Option::is_none")]
7652 pub value: Option<String>,
7653}
7654impl VariableValue {
7655 pub fn new() -> Self {
7656 Self::default()
7657 }
7658}
7659#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7660pub struct VirtualMachine {
7661 #[doc = "A task agent."]
7662 #[serde(default, skip_serializing_if = "Option::is_none")]
7663 pub agent: Option<TaskAgent>,
7664 #[serde(default, skip_serializing_if = "Option::is_none")]
7665 pub id: Option<i32>,
7666 #[serde(
7667 default,
7668 deserialize_with = "crate::serde::deserialize_null_as_default",
7669 skip_serializing_if = "Vec::is_empty"
7670 )]
7671 pub tags: Vec<String>,
7672}
7673impl VirtualMachine {
7674 pub fn new() -> Self {
7675 Self::default()
7676 }
7677}
7678#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7679pub struct VirtualMachineGroup {
7680 #[serde(flatten)]
7681 pub environment_resource: EnvironmentResource,
7682 #[serde(rename = "poolId", default, skip_serializing_if = "Option::is_none")]
7683 pub pool_id: Option<i32>,
7684}
7685impl VirtualMachineGroup {
7686 pub fn new() -> Self {
7687 Self::default()
7688 }
7689}
7690#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7691pub struct VirtualMachineGroupCreateParameters {
7692 #[serde(default, skip_serializing_if = "Option::is_none")]
7693 pub name: Option<String>,
7694}
7695impl VirtualMachineGroupCreateParameters {
7696 pub fn new() -> Self {
7697 Self::default()
7698 }
7699}
7700#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7701pub struct VirtualMachineResource {
7702 #[serde(flatten)]
7703 pub environment_resource: EnvironmentResource,
7704 #[doc = "A task agent."]
7705 #[serde(default, skip_serializing_if = "Option::is_none")]
7706 pub agent: Option<TaskAgent>,
7707}
7708impl VirtualMachineResource {
7709 pub fn new() -> Self {
7710 Self::default()
7711 }
7712}
7713#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7714pub struct VirtualMachineResourceCreateParameters {
7715 #[serde(
7716 rename = "virtualMachineResource",
7717 default,
7718 skip_serializing_if = "Option::is_none"
7719 )]
7720 pub virtual_machine_resource: Option<VirtualMachineResource>,
7721}
7722impl VirtualMachineResourceCreateParameters {
7723 pub fn new() -> Self {
7724 Self::default()
7725 }
7726}
7727#[doc = "This class is used to serialize collections as a single JSON object on the wire."]
7728#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7729pub struct VssJsonCollectionWrapper {
7730 #[serde(flatten)]
7731 pub vss_json_collection_wrapper_base: VssJsonCollectionWrapperBase,
7732 #[doc = "The serialized item."]
7733 #[serde(default, skip_serializing_if = "Option::is_none")]
7734 pub value: Option<String>,
7735}
7736impl VssJsonCollectionWrapper {
7737 pub fn new() -> Self {
7738 Self::default()
7739 }
7740}
7741#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
7742pub struct VssJsonCollectionWrapperBase {
7743 #[doc = "The number of serialized items."]
7744 #[serde(default, skip_serializing_if = "Option::is_none")]
7745 pub count: Option<i32>,
7746}
7747impl VssJsonCollectionWrapperBase {
7748 pub fn new() -> Self {
7749 Self::default()
7750 }
7751}