1use serde::{Deserialize, Serialize};
4use serde_json::Value;
5use std::collections::BTreeMap;
6
7#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
9pub struct AuthActivateWorkloadRequest {
10 #[serde(rename = "handoffId")]
11 pub handoff_id: String,
12}
13
14#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
16pub struct AuthActivateWorkloadResponse(pub Value);
17
18#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
20pub struct AuthClearLoginPortalSelectionRequest {
21 #[serde(rename = "contractId")]
22 pub contract_id: String,
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
27pub struct AuthClearLoginPortalSelectionResponse {
28 pub success: bool,
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
33pub struct AuthClearWorkloadPortalSelectionRequest {
34 #[serde(rename = "profileId")]
35 pub profile_id: String,
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
40pub struct AuthClearWorkloadPortalSelectionResponse {
41 pub success: bool,
42}
43
44#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
46pub struct AuthCreatePortalRequest {
47 #[serde(rename = "appContractId")]
48 #[serde(skip_serializing_if = "Option::is_none")]
49 pub app_contract_id: Option<String>,
50 #[serde(rename = "entryUrl")]
51 pub entry_url: String,
52 #[serde(rename = "portalId")]
53 pub portal_id: String,
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
59pub struct AuthCreatePortalResponsePortal {
60 #[serde(rename = "appContractId")]
61 #[serde(skip_serializing_if = "Option::is_none")]
62 pub app_contract_id: Option<String>,
63 pub disabled: bool,
64 #[serde(rename = "entryUrl")]
65 pub entry_url: String,
66 #[serde(rename = "portalId")]
67 pub portal_id: String,
68}
69
70#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
71pub struct AuthCreatePortalResponse {
72 pub portal: AuthCreatePortalResponsePortal,
73}
74
75#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
77pub struct AuthCreateWorkloadProfileRequest {
78 #[serde(rename = "allowedDigests")]
79 pub allowed_digests: Vec<String>,
80 #[serde(skip_serializing_if = "Option::is_none")]
81 pub contract: Option<BTreeMap<String, Value>>,
82 #[serde(rename = "contractId")]
83 pub contract_id: String,
84 #[serde(rename = "profileId")]
85 pub profile_id: String,
86 #[serde(rename = "reviewMode")]
87 #[serde(skip_serializing_if = "Option::is_none")]
88 pub review_mode: Option<Value>,
89}
90
91#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
94pub struct AuthCreateWorkloadProfileResponseProfile {
95 #[serde(rename = "allowedDigests")]
96 pub allowed_digests: Vec<String>,
97 #[serde(rename = "contractId")]
98 pub contract_id: String,
99 pub disabled: bool,
100 #[serde(rename = "profileId")]
101 pub profile_id: String,
102 #[serde(rename = "reviewMode")]
103 #[serde(skip_serializing_if = "Option::is_none")]
104 pub review_mode: Option<Value>,
105}
106
107#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
108pub struct AuthCreateWorkloadProfileResponse {
109 pub profile: AuthCreateWorkloadProfileResponseProfile,
110}
111
112#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
114pub struct AuthDecideWorkloadActivationReviewRequest {
115 pub decision: Value,
116 #[serde(skip_serializing_if = "Option::is_none")]
117 pub reason: Option<String>,
118 #[serde(rename = "reviewId")]
119 pub review_id: String,
120}
121
122#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
126pub struct AuthDecideWorkloadActivationReviewResponseActivationActivatedBy {
127 pub id: String,
128 pub origin: String,
129}
130
131#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
132pub struct AuthDecideWorkloadActivationReviewResponseActivation {
133 #[serde(rename = "activatedAt")]
134 pub activated_at: String,
135 #[serde(rename = "activatedBy")]
136 #[serde(skip_serializing_if = "Option::is_none")]
137 pub activated_by: Option<AuthDecideWorkloadActivationReviewResponseActivationActivatedBy>,
138 #[serde(rename = "instanceId")]
139 pub instance_id: String,
140 #[serde(rename = "profileId")]
141 pub profile_id: String,
142 #[serde(rename = "publicIdentityKey")]
143 pub public_identity_key: String,
144 #[serde(rename = "revokedAt")]
145 pub revoked_at: Value,
146 pub state: Value,
147}
148
149#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
151pub struct AuthDecideWorkloadActivationReviewResponseReview {
152 #[serde(rename = "decidedAt")]
153 pub decided_at: Value,
154 #[serde(rename = "instanceId")]
155 pub instance_id: String,
156 #[serde(rename = "profileId")]
157 pub profile_id: String,
158 #[serde(rename = "publicIdentityKey")]
159 pub public_identity_key: String,
160 #[serde(skip_serializing_if = "Option::is_none")]
161 pub reason: Option<String>,
162 #[serde(rename = "requestedAt")]
163 pub requested_at: String,
164 #[serde(rename = "reviewId")]
165 pub review_id: String,
166 pub state: Value,
167}
168
169#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
170pub struct AuthDecideWorkloadActivationReviewResponse {
171 #[serde(skip_serializing_if = "Option::is_none")]
172 pub activation: Option<AuthDecideWorkloadActivationReviewResponseActivation>,
173 #[serde(rename = "confirmationCode")]
174 #[serde(skip_serializing_if = "Option::is_none")]
175 pub confirmation_code: Option<String>,
176 pub review: AuthDecideWorkloadActivationReviewResponseReview,
177}
178
179#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
181pub struct AuthDisablePortalRequest {
182 #[serde(rename = "portalId")]
183 pub portal_id: String,
184}
185
186#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
188pub struct AuthDisablePortalResponse {
189 pub success: bool,
190}
191
192#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
194pub struct AuthDisableWorkloadInstanceRequest {
195 #[serde(rename = "instanceId")]
196 pub instance_id: String,
197}
198
199#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
201pub struct AuthDisableWorkloadInstanceResponse {
202 pub success: bool,
203}
204
205#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
207pub struct AuthDisableWorkloadProfileRequest {
208 #[serde(rename = "profileId")]
209 pub profile_id: String,
210}
211
212#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
214pub struct AuthDisableWorkloadProfileResponse {
215 pub success: bool,
216}
217
218#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
220pub struct AuthGetInstalledContractRequest {
221 pub digest: String,
222}
223
224#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
230pub struct AuthGetInstalledContractResponseContractAnalysisEventsEventsItem {
231 pub key: String,
232 #[serde(rename = "publishCapabilities")]
233 pub publish_capabilities: Vec<String>,
234 pub subject: String,
235 #[serde(rename = "subscribeCapabilities")]
236 pub subscribe_capabilities: Vec<String>,
237 #[serde(rename = "wildcardSubject")]
238 pub wildcard_subject: String,
239}
240
241#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
242pub struct AuthGetInstalledContractResponseContractAnalysisEvents {
243 pub events: Vec<AuthGetInstalledContractResponseContractAnalysisEventsEventsItem>,
244}
245
246#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
249pub struct AuthGetInstalledContractResponseContractAnalysisNatsPublishItem {
250 pub kind: String,
251 #[serde(rename = "requiredCapabilities")]
252 pub required_capabilities: Vec<String>,
253 pub subject: String,
254 #[serde(rename = "wildcardSubject")]
255 pub wildcard_subject: String,
256}
257
258#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
260pub struct AuthGetInstalledContractResponseContractAnalysisNatsSubscribeItem {
261 pub kind: String,
262 #[serde(rename = "requiredCapabilities")]
263 pub required_capabilities: Vec<String>,
264 pub subject: String,
265 #[serde(rename = "wildcardSubject")]
266 pub wildcard_subject: String,
267}
268
269#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
270pub struct AuthGetInstalledContractResponseContractAnalysisNats {
271 pub publish: Vec<AuthGetInstalledContractResponseContractAnalysisNatsPublishItem>,
272 pub subscribe: Vec<AuthGetInstalledContractResponseContractAnalysisNatsSubscribeItem>,
273}
274
275#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
279pub struct AuthGetInstalledContractResponseContractAnalysisResourcesJobsItemPayload {
280 pub schema: String,
281}
282
283#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
285pub struct AuthGetInstalledContractResponseContractAnalysisResourcesJobsItemResult {
286 pub schema: String,
287}
288
289#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
290pub struct AuthGetInstalledContractResponseContractAnalysisResourcesJobsItem {
291 #[serde(rename = "ackWaitMs")]
292 pub ack_wait_ms: f64,
293 #[serde(rename = "backoffMs")]
294 pub backoff_ms: Vec<f64>,
295 pub concurrency: f64,
296 #[serde(rename = "defaultDeadlineMs")]
297 #[serde(skip_serializing_if = "Option::is_none")]
298 pub default_deadline_ms: Option<f64>,
299 pub dlq: bool,
300 pub logs: bool,
301 #[serde(rename = "maxDeliver")]
302 pub max_deliver: f64,
303 pub payload: AuthGetInstalledContractResponseContractAnalysisResourcesJobsItemPayload,
304 pub progress: bool,
305 #[serde(rename = "queueType")]
306 pub queue_type: String,
307 #[serde(skip_serializing_if = "Option::is_none")]
308 pub result: Option<AuthGetInstalledContractResponseContractAnalysisResourcesJobsItemResult>,
309}
310
311#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
313pub struct AuthGetInstalledContractResponseContractAnalysisResourcesKvItem {
314 pub alias: String,
315 pub history: f64,
316 #[serde(rename = "maxValueBytes")]
317 #[serde(skip_serializing_if = "Option::is_none")]
318 pub max_value_bytes: Option<f64>,
319 pub purpose: String,
320 pub required: bool,
321 #[serde(rename = "ttlMs")]
322 pub ttl_ms: f64,
323}
324
325#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
328pub struct AuthGetInstalledContractResponseContractAnalysisResourcesStreamsItemSourcesItem {
329 #[serde(rename = "filterSubject")]
330 #[serde(skip_serializing_if = "Option::is_none")]
331 pub filter_subject: Option<String>,
332 #[serde(rename = "fromAlias")]
333 pub from_alias: String,
334 #[serde(rename = "streamName")]
335 pub stream_name: String,
336 #[serde(rename = "subjectTransformDest")]
337 #[serde(skip_serializing_if = "Option::is_none")]
338 pub subject_transform_dest: Option<String>,
339}
340
341#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
342pub struct AuthGetInstalledContractResponseContractAnalysisResourcesStreamsItem {
343 pub alias: String,
344 #[serde(skip_serializing_if = "Option::is_none")]
345 pub discard: Option<String>,
346 #[serde(rename = "maxAgeMs")]
347 #[serde(skip_serializing_if = "Option::is_none")]
348 pub max_age_ms: Option<f64>,
349 #[serde(rename = "maxBytes")]
350 #[serde(skip_serializing_if = "Option::is_none")]
351 pub max_bytes: Option<f64>,
352 #[serde(rename = "maxMsgs")]
353 #[serde(skip_serializing_if = "Option::is_none")]
354 pub max_msgs: Option<f64>,
355 #[serde(rename = "numReplicas")]
356 #[serde(skip_serializing_if = "Option::is_none")]
357 pub num_replicas: Option<f64>,
358 pub purpose: String,
359 pub required: bool,
360 #[serde(skip_serializing_if = "Option::is_none")]
361 pub retention: Option<String>,
362 #[serde(skip_serializing_if = "Option::is_none")]
363 pub sources: Option<Vec<AuthGetInstalledContractResponseContractAnalysisResourcesStreamsItemSourcesItem>>,
364 #[serde(skip_serializing_if = "Option::is_none")]
365 pub storage: Option<String>,
366 pub subjects: Vec<String>,
367}
368
369#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
370pub struct AuthGetInstalledContractResponseContractAnalysisResources {
371 pub jobs: Vec<AuthGetInstalledContractResponseContractAnalysisResourcesJobsItem>,
372 pub kv: Vec<AuthGetInstalledContractResponseContractAnalysisResourcesKvItem>,
373 pub streams: Vec<AuthGetInstalledContractResponseContractAnalysisResourcesStreamsItem>,
374}
375
376#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
379pub struct AuthGetInstalledContractResponseContractAnalysisRpcMethodsItem {
380 #[serde(rename = "callerCapabilities")]
381 pub caller_capabilities: Vec<String>,
382 pub key: String,
383 pub subject: String,
384 #[serde(rename = "wildcardSubject")]
385 pub wildcard_subject: String,
386}
387
388#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
389pub struct AuthGetInstalledContractResponseContractAnalysisRpc {
390 pub methods: Vec<AuthGetInstalledContractResponseContractAnalysisRpcMethodsItem>,
391}
392
393#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
396pub struct AuthGetInstalledContractResponseContractAnalysisSubjectsSubjectsItem {
397 pub key: String,
398 #[serde(rename = "publishCapabilities")]
399 pub publish_capabilities: Vec<String>,
400 pub subject: String,
401 #[serde(rename = "subscribeCapabilities")]
402 pub subscribe_capabilities: Vec<String>,
403}
404
405#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
406pub struct AuthGetInstalledContractResponseContractAnalysisSubjects {
407 pub subjects: Vec<AuthGetInstalledContractResponseContractAnalysisSubjectsSubjectsItem>,
408}
409
410#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
411pub struct AuthGetInstalledContractResponseContractAnalysis {
412 pub events: AuthGetInstalledContractResponseContractAnalysisEvents,
413 pub namespaces: Vec<String>,
414 pub nats: AuthGetInstalledContractResponseContractAnalysisNats,
415 pub resources: AuthGetInstalledContractResponseContractAnalysisResources,
416 pub rpc: AuthGetInstalledContractResponseContractAnalysisRpc,
417 #[serde(skip_serializing_if = "Option::is_none")]
418 pub subjects: Option<AuthGetInstalledContractResponseContractAnalysisSubjects>,
419}
420
421#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
423pub struct AuthGetInstalledContractResponseContractAnalysisSummary {
424 pub events: f64,
425 #[serde(rename = "jobsQueues")]
426 pub jobs_queues: f64,
427 #[serde(rename = "kvResources")]
428 pub kv_resources: f64,
429 pub namespaces: Vec<String>,
430 #[serde(rename = "natsPublish")]
431 pub nats_publish: f64,
432 #[serde(rename = "natsSubscribe")]
433 pub nats_subscribe: f64,
434 #[serde(rename = "rpcMethods")]
435 pub rpc_methods: f64,
436 #[serde(rename = "streamResources")]
437 pub stream_resources: f64,
438}
439
440#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
445pub struct AuthGetInstalledContractResponseContractResourceBindingsJobsQueuesValuePayload {
446 pub schema: String,
447}
448
449#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
451pub struct AuthGetInstalledContractResponseContractResourceBindingsJobsQueuesValueResult {
452 pub schema: String,
453}
454
455#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
456pub struct AuthGetInstalledContractResponseContractResourceBindingsJobsQueuesValue {
457 #[serde(rename = "ackWaitMs")]
458 pub ack_wait_ms: i64,
459 #[serde(rename = "backoffMs")]
460 pub backoff_ms: Vec<i64>,
461 pub concurrency: i64,
462 #[serde(rename = "consumerName")]
463 pub consumer_name: String,
464 #[serde(rename = "defaultDeadlineMs")]
465 #[serde(skip_serializing_if = "Option::is_none")]
466 pub default_deadline_ms: Option<i64>,
467 pub dlq: bool,
468 pub logs: bool,
469 #[serde(rename = "maxDeliver")]
470 pub max_deliver: i64,
471 pub payload: AuthGetInstalledContractResponseContractResourceBindingsJobsQueuesValuePayload,
472 pub progress: bool,
473 #[serde(rename = "publishPrefix")]
474 pub publish_prefix: String,
475 #[serde(rename = "queueType")]
476 pub queue_type: String,
477 #[serde(skip_serializing_if = "Option::is_none")]
478 pub result: Option<AuthGetInstalledContractResponseContractResourceBindingsJobsQueuesValueResult>,
479 #[serde(rename = "workSubject")]
480 pub work_subject: String,
481}
482
483#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
484pub struct AuthGetInstalledContractResponseContractResourceBindingsJobs {
485 pub namespace: String,
486 pub queues: BTreeMap<String, AuthGetInstalledContractResponseContractResourceBindingsJobsQueuesValue>,
487}
488
489#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
491pub struct AuthGetInstalledContractResponseContractResourceBindingsKvValue {
492 pub bucket: String,
493 pub history: i64,
494 #[serde(rename = "maxValueBytes")]
495 #[serde(skip_serializing_if = "Option::is_none")]
496 pub max_value_bytes: Option<i64>,
497 #[serde(rename = "ttlMs")]
498 pub ttl_ms: i64,
499}
500
501#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
504pub struct AuthGetInstalledContractResponseContractResourceBindingsStreamsValueSourcesItem {
505 #[serde(rename = "filterSubject")]
506 #[serde(skip_serializing_if = "Option::is_none")]
507 pub filter_subject: Option<String>,
508 #[serde(rename = "fromAlias")]
509 pub from_alias: String,
510 #[serde(rename = "streamName")]
511 pub stream_name: String,
512 #[serde(rename = "subjectTransformDest")]
513 #[serde(skip_serializing_if = "Option::is_none")]
514 pub subject_transform_dest: Option<String>,
515}
516
517#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
518pub struct AuthGetInstalledContractResponseContractResourceBindingsStreamsValue {
519 #[serde(skip_serializing_if = "Option::is_none")]
520 pub discard: Option<String>,
521 #[serde(rename = "maxAgeMs")]
522 #[serde(skip_serializing_if = "Option::is_none")]
523 pub max_age_ms: Option<i64>,
524 #[serde(rename = "maxBytes")]
525 #[serde(skip_serializing_if = "Option::is_none")]
526 pub max_bytes: Option<i64>,
527 #[serde(rename = "maxMsgs")]
528 #[serde(skip_serializing_if = "Option::is_none")]
529 pub max_msgs: Option<i64>,
530 pub name: String,
531 #[serde(rename = "numReplicas")]
532 #[serde(skip_serializing_if = "Option::is_none")]
533 pub num_replicas: Option<i64>,
534 #[serde(skip_serializing_if = "Option::is_none")]
535 pub retention: Option<String>,
536 #[serde(skip_serializing_if = "Option::is_none")]
537 pub sources: Option<Vec<AuthGetInstalledContractResponseContractResourceBindingsStreamsValueSourcesItem>>,
538 #[serde(skip_serializing_if = "Option::is_none")]
539 pub storage: Option<String>,
540 pub subjects: Vec<String>,
541}
542
543#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
544pub struct AuthGetInstalledContractResponseContractResourceBindings {
545 #[serde(skip_serializing_if = "Option::is_none")]
546 pub jobs: Option<AuthGetInstalledContractResponseContractResourceBindingsJobs>,
547 #[serde(skip_serializing_if = "Option::is_none")]
548 pub kv: Option<BTreeMap<String, AuthGetInstalledContractResponseContractResourceBindingsKvValue>>,
549 #[serde(skip_serializing_if = "Option::is_none")]
550 pub streams: Option<BTreeMap<String, AuthGetInstalledContractResponseContractResourceBindingsStreamsValue>>,
551}
552
553#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
558pub struct AuthGetInstalledContractResponseContractResourcesJobsQueuesValuePayload {
559 pub schema: String,
560}
561
562#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
564pub struct AuthGetInstalledContractResponseContractResourcesJobsQueuesValueResult {
565 pub schema: String,
566}
567
568#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
569pub struct AuthGetInstalledContractResponseContractResourcesJobsQueuesValue {
570 #[serde(rename = "ackWaitMs")]
571 #[serde(skip_serializing_if = "Option::is_none")]
572 pub ack_wait_ms: Option<i64>,
573 #[serde(rename = "backoffMs")]
574 #[serde(skip_serializing_if = "Option::is_none")]
575 pub backoff_ms: Option<Vec<i64>>,
576 #[serde(skip_serializing_if = "Option::is_none")]
577 pub concurrency: Option<i64>,
578 #[serde(rename = "defaultDeadlineMs")]
579 #[serde(skip_serializing_if = "Option::is_none")]
580 pub default_deadline_ms: Option<i64>,
581 #[serde(skip_serializing_if = "Option::is_none")]
582 pub dlq: Option<bool>,
583 #[serde(skip_serializing_if = "Option::is_none")]
584 pub logs: Option<bool>,
585 #[serde(rename = "maxDeliver")]
586 #[serde(skip_serializing_if = "Option::is_none")]
587 pub max_deliver: Option<i64>,
588 pub payload: AuthGetInstalledContractResponseContractResourcesJobsQueuesValuePayload,
589 #[serde(skip_serializing_if = "Option::is_none")]
590 pub progress: Option<bool>,
591 #[serde(skip_serializing_if = "Option::is_none")]
592 pub result: Option<AuthGetInstalledContractResponseContractResourcesJobsQueuesValueResult>,
593}
594
595#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
596pub struct AuthGetInstalledContractResponseContractResourcesJobs {
597 pub queues: BTreeMap<String, AuthGetInstalledContractResponseContractResourcesJobsQueuesValue>,
598}
599
600#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
602pub struct AuthGetInstalledContractResponseContractResourcesKvValue {
603 #[serde(skip_serializing_if = "Option::is_none")]
604 pub history: Option<i64>,
605 #[serde(rename = "maxValueBytes")]
606 #[serde(skip_serializing_if = "Option::is_none")]
607 pub max_value_bytes: Option<i64>,
608 pub purpose: String,
609 #[serde(skip_serializing_if = "Option::is_none")]
610 pub required: Option<bool>,
611 #[serde(rename = "ttlMs")]
612 #[serde(skip_serializing_if = "Option::is_none")]
613 pub ttl_ms: Option<i64>,
614}
615
616#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
619pub struct AuthGetInstalledContractResponseContractResourcesStreamsValueSourcesItem {
620 #[serde(rename = "filterSubject")]
621 #[serde(skip_serializing_if = "Option::is_none")]
622 pub filter_subject: Option<String>,
623 #[serde(rename = "fromAlias")]
624 pub from_alias: String,
625 #[serde(rename = "subjectTransformDest")]
626 #[serde(skip_serializing_if = "Option::is_none")]
627 pub subject_transform_dest: Option<String>,
628}
629
630#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
631pub struct AuthGetInstalledContractResponseContractResourcesStreamsValue {
632 #[serde(skip_serializing_if = "Option::is_none")]
633 pub discard: Option<String>,
634 #[serde(rename = "maxAgeMs")]
635 #[serde(skip_serializing_if = "Option::is_none")]
636 pub max_age_ms: Option<i64>,
637 #[serde(rename = "maxBytes")]
638 #[serde(skip_serializing_if = "Option::is_none")]
639 pub max_bytes: Option<i64>,
640 #[serde(rename = "maxMsgs")]
641 #[serde(skip_serializing_if = "Option::is_none")]
642 pub max_msgs: Option<i64>,
643 #[serde(rename = "numReplicas")]
644 #[serde(skip_serializing_if = "Option::is_none")]
645 pub num_replicas: Option<i64>,
646 pub purpose: String,
647 #[serde(skip_serializing_if = "Option::is_none")]
648 pub required: Option<bool>,
649 #[serde(skip_serializing_if = "Option::is_none")]
650 pub retention: Option<String>,
651 #[serde(skip_serializing_if = "Option::is_none")]
652 pub sources: Option<Vec<AuthGetInstalledContractResponseContractResourcesStreamsValueSourcesItem>>,
653 #[serde(skip_serializing_if = "Option::is_none")]
654 pub storage: Option<String>,
655 pub subjects: Vec<String>,
656}
657
658#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
659pub struct AuthGetInstalledContractResponseContractResources {
660 #[serde(skip_serializing_if = "Option::is_none")]
661 pub jobs: Option<AuthGetInstalledContractResponseContractResourcesJobs>,
662 #[serde(skip_serializing_if = "Option::is_none")]
663 pub kv: Option<BTreeMap<String, AuthGetInstalledContractResponseContractResourcesKvValue>>,
664 #[serde(skip_serializing_if = "Option::is_none")]
665 pub streams: Option<BTreeMap<String, AuthGetInstalledContractResponseContractResourcesStreamsValue>>,
666}
667
668#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
669pub struct AuthGetInstalledContractResponseContract {
670 #[serde(skip_serializing_if = "Option::is_none")]
671 pub analysis: Option<AuthGetInstalledContractResponseContractAnalysis>,
672 #[serde(rename = "analysisSummary")]
673 #[serde(skip_serializing_if = "Option::is_none")]
674 pub analysis_summary: Option<AuthGetInstalledContractResponseContractAnalysisSummary>,
675 pub contract: BTreeMap<String, Value>,
676 pub description: String,
677 pub digest: String,
678 #[serde(rename = "displayName")]
679 pub display_name: String,
680 pub id: String,
681 #[serde(rename = "installedAt")]
682 pub installed_at: String,
683 #[serde(rename = "resourceBindings")]
684 #[serde(skip_serializing_if = "Option::is_none")]
685 pub resource_bindings: Option<AuthGetInstalledContractResponseContractResourceBindings>,
686 #[serde(skip_serializing_if = "Option::is_none")]
687 pub resources: Option<AuthGetInstalledContractResponseContractResources>,
688 #[serde(rename = "sessionKey")]
689 #[serde(skip_serializing_if = "Option::is_none")]
690 pub session_key: Option<String>,
691}
692
693#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
694pub struct AuthGetInstalledContractResponse {
695 pub contract: AuthGetInstalledContractResponseContract,
696}
697
698#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
701pub struct AuthGetLoginPortalDefaultResponseDefaultPortal {
702 #[serde(rename = "portalId")]
703 pub portal_id: Value,
704}
705
706#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
707pub struct AuthGetLoginPortalDefaultResponse {
708 #[serde(rename = "defaultPortal")]
709 pub default_portal: AuthGetLoginPortalDefaultResponseDefaultPortal,
710}
711
712#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
714pub struct AuthGetWorkloadActivationStatusRequest {
715 #[serde(rename = "handoffId")]
716 pub handoff_id: String,
717}
718
719#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
721pub struct AuthGetWorkloadActivationStatusResponse(pub Value);
722
723#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
725pub struct AuthGetWorkloadConnectInfoRequest {
726 #[serde(rename = "contractDigest")]
727 pub contract_digest: String,
728 pub iat: f64,
729 #[serde(rename = "publicIdentityKey")]
730 pub public_identity_key: String,
731 pub sig: String,
732}
733
734#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
738pub struct AuthGetWorkloadConnectInfoResponseConnectInfoAuth {
739 #[serde(rename = "iatSkewSeconds")]
740 pub iat_skew_seconds: f64,
741 pub mode: String,
742}
743
744#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
747pub struct AuthGetWorkloadConnectInfoResponseConnectInfoTransportSentinel {
748 pub jwt: String,
749 pub seed: String,
750}
751
752#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
753pub struct AuthGetWorkloadConnectInfoResponseConnectInfoTransport {
754 #[serde(rename = "natsServers")]
755 pub nats_servers: Vec<String>,
756 pub sentinel: AuthGetWorkloadConnectInfoResponseConnectInfoTransportSentinel,
757}
758
759#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
760pub struct AuthGetWorkloadConnectInfoResponseConnectInfo {
761 pub auth: AuthGetWorkloadConnectInfoResponseConnectInfoAuth,
762 #[serde(rename = "contractDigest")]
763 pub contract_digest: String,
764 #[serde(rename = "contractId")]
765 pub contract_id: String,
766 #[serde(rename = "instanceId")]
767 pub instance_id: String,
768 #[serde(rename = "profileId")]
769 pub profile_id: String,
770 pub transport: AuthGetWorkloadConnectInfoResponseConnectInfoTransport,
771}
772
773#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
774pub struct AuthGetWorkloadConnectInfoResponse {
775 #[serde(rename = "connectInfo")]
776 pub connect_info: AuthGetWorkloadConnectInfoResponseConnectInfo,
777 pub status: String,
778}
779
780#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
783pub struct AuthGetWorkloadPortalDefaultResponseDefaultPortal {
784 #[serde(rename = "portalId")]
785 pub portal_id: Value,
786}
787
788#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
789pub struct AuthGetWorkloadPortalDefaultResponse {
790 #[serde(rename = "defaultPortal")]
791 pub default_portal: AuthGetWorkloadPortalDefaultResponseDefaultPortal,
792}
793
794#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
797pub struct AuthHealthResponseChecksItem {
798 #[serde(skip_serializing_if = "Option::is_none")]
799 pub error: Option<String>,
800 #[serde(rename = "latencyMs")]
801 pub latency_ms: f64,
802 pub name: String,
803 pub status: Value,
804}
805
806#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
807pub struct AuthHealthResponse {
808 pub checks: Vec<AuthHealthResponseChecksItem>,
809 pub service: String,
810 pub status: Value,
811 pub timestamp: String,
812}
813
814#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
816pub struct AuthInstallServiceRequest {
817 #[serde(skip_serializing_if = "Option::is_none")]
818 pub active: Option<bool>,
819 pub contract: BTreeMap<String, Value>,
820 pub description: String,
821 #[serde(rename = "displayName")]
822 pub display_name: String,
823 pub namespaces: Vec<String>,
824 #[serde(rename = "sessionKey")]
825 pub session_key: String,
826}
827
828#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
834pub struct AuthInstallServiceResponseResourceBindingsJobsQueuesValuePayload {
835 pub schema: String,
836}
837
838#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
840pub struct AuthInstallServiceResponseResourceBindingsJobsQueuesValueResult {
841 pub schema: String,
842}
843
844#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
845pub struct AuthInstallServiceResponseResourceBindingsJobsQueuesValue {
846 #[serde(rename = "ackWaitMs")]
847 pub ack_wait_ms: i64,
848 #[serde(rename = "backoffMs")]
849 pub backoff_ms: Vec<i64>,
850 pub concurrency: i64,
851 #[serde(rename = "consumerName")]
852 pub consumer_name: String,
853 #[serde(rename = "defaultDeadlineMs")]
854 #[serde(skip_serializing_if = "Option::is_none")]
855 pub default_deadline_ms: Option<i64>,
856 pub dlq: bool,
857 pub logs: bool,
858 #[serde(rename = "maxDeliver")]
859 pub max_deliver: i64,
860 pub payload: AuthInstallServiceResponseResourceBindingsJobsQueuesValuePayload,
861 pub progress: bool,
862 #[serde(rename = "publishPrefix")]
863 pub publish_prefix: String,
864 #[serde(rename = "queueType")]
865 pub queue_type: String,
866 #[serde(skip_serializing_if = "Option::is_none")]
867 pub result: Option<AuthInstallServiceResponseResourceBindingsJobsQueuesValueResult>,
868 #[serde(rename = "workSubject")]
869 pub work_subject: String,
870}
871
872#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
873pub struct AuthInstallServiceResponseResourceBindingsJobs {
874 pub namespace: String,
875 pub queues: BTreeMap<String, AuthInstallServiceResponseResourceBindingsJobsQueuesValue>,
876}
877
878#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
880pub struct AuthInstallServiceResponseResourceBindingsKvValue {
881 pub bucket: String,
882 pub history: i64,
883 #[serde(rename = "maxValueBytes")]
884 #[serde(skip_serializing_if = "Option::is_none")]
885 pub max_value_bytes: Option<i64>,
886 #[serde(rename = "ttlMs")]
887 pub ttl_ms: i64,
888}
889
890#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
893pub struct AuthInstallServiceResponseResourceBindingsStreamsValueSourcesItem {
894 #[serde(rename = "filterSubject")]
895 #[serde(skip_serializing_if = "Option::is_none")]
896 pub filter_subject: Option<String>,
897 #[serde(rename = "fromAlias")]
898 pub from_alias: String,
899 #[serde(rename = "streamName")]
900 pub stream_name: String,
901 #[serde(rename = "subjectTransformDest")]
902 #[serde(skip_serializing_if = "Option::is_none")]
903 pub subject_transform_dest: Option<String>,
904}
905
906#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
907pub struct AuthInstallServiceResponseResourceBindingsStreamsValue {
908 #[serde(skip_serializing_if = "Option::is_none")]
909 pub discard: Option<String>,
910 #[serde(rename = "maxAgeMs")]
911 #[serde(skip_serializing_if = "Option::is_none")]
912 pub max_age_ms: Option<i64>,
913 #[serde(rename = "maxBytes")]
914 #[serde(skip_serializing_if = "Option::is_none")]
915 pub max_bytes: Option<i64>,
916 #[serde(rename = "maxMsgs")]
917 #[serde(skip_serializing_if = "Option::is_none")]
918 pub max_msgs: Option<i64>,
919 pub name: String,
920 #[serde(rename = "numReplicas")]
921 #[serde(skip_serializing_if = "Option::is_none")]
922 pub num_replicas: Option<i64>,
923 #[serde(skip_serializing_if = "Option::is_none")]
924 pub retention: Option<String>,
925 #[serde(skip_serializing_if = "Option::is_none")]
926 pub sources: Option<Vec<AuthInstallServiceResponseResourceBindingsStreamsValueSourcesItem>>,
927 #[serde(skip_serializing_if = "Option::is_none")]
928 pub storage: Option<String>,
929 pub subjects: Vec<String>,
930}
931
932#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
933pub struct AuthInstallServiceResponseResourceBindings {
934 #[serde(skip_serializing_if = "Option::is_none")]
935 pub jobs: Option<AuthInstallServiceResponseResourceBindingsJobs>,
936 #[serde(skip_serializing_if = "Option::is_none")]
937 pub kv: Option<BTreeMap<String, AuthInstallServiceResponseResourceBindingsKvValue>>,
938 #[serde(skip_serializing_if = "Option::is_none")]
939 pub streams: Option<BTreeMap<String, AuthInstallServiceResponseResourceBindingsStreamsValue>>,
940}
941
942#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
943pub struct AuthInstallServiceResponse {
944 #[serde(rename = "contractDigest")]
945 pub contract_digest: String,
946 #[serde(rename = "contractId")]
947 pub contract_id: String,
948 #[serde(rename = "resourceBindings")]
949 pub resource_bindings: AuthInstallServiceResponseResourceBindings,
950 #[serde(rename = "sessionKey")]
951 pub session_key: String,
952 pub success: bool,
953}
954
955#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
957pub struct AuthKickConnectionRequest {
958 #[serde(rename = "userNkey")]
959 pub user_nkey: String,
960}
961
962#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
964pub struct AuthKickConnectionResponse {
965 pub success: bool,
966}
967
968#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
970pub struct AuthListApprovalsRequest {
971 #[serde(skip_serializing_if = "Option::is_none")]
972 pub digest: Option<String>,
973 #[serde(skip_serializing_if = "Option::is_none")]
974 pub user: Option<String>,
975}
976
977#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
981pub struct AuthListApprovalsResponseApprovalsItemApproval {
982 pub capabilities: Vec<String>,
983 #[serde(rename = "contractDigest")]
984 pub contract_digest: String,
985 #[serde(rename = "contractId")]
986 pub contract_id: String,
987 pub description: String,
988 #[serde(rename = "displayName")]
989 pub display_name: String,
990}
991
992#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
993pub struct AuthListApprovalsResponseApprovalsItem {
994 pub answer: Value,
995 #[serde(rename = "answeredAt")]
996 pub answered_at: String,
997 pub approval: AuthListApprovalsResponseApprovalsItemApproval,
998 #[serde(rename = "updatedAt")]
999 pub updated_at: String,
1000 pub user: String,
1001}
1002
1003#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1004pub struct AuthListApprovalsResponse {
1005 pub approvals: Vec<AuthListApprovalsResponseApprovalsItem>,
1006}
1007
1008#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1010pub struct AuthListConnectionsRequest {
1011 #[serde(rename = "sessionKey")]
1012 #[serde(skip_serializing_if = "Option::is_none")]
1013 pub session_key: Option<String>,
1014 #[serde(skip_serializing_if = "Option::is_none")]
1015 pub user: Option<String>,
1016}
1017
1018#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1021pub struct AuthListConnectionsResponseConnectionsItem {
1022 #[serde(rename = "clientId")]
1023 pub client_id: f64,
1024 #[serde(rename = "connectedAt")]
1025 pub connected_at: String,
1026 pub key: String,
1027 #[serde(rename = "serverId")]
1028 pub server_id: String,
1029}
1030
1031#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1032pub struct AuthListConnectionsResponse {
1033 pub connections: Vec<AuthListConnectionsResponseConnectionsItem>,
1034}
1035
1036#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1038pub struct AuthListInstalledContractsRequest {
1039 #[serde(rename = "sessionKey")]
1040 #[serde(skip_serializing_if = "Option::is_none")]
1041 pub session_key: Option<String>,
1042}
1043
1044#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1048pub struct AuthListInstalledContractsResponseContractsItemAnalysisSummary {
1049 pub events: f64,
1050 #[serde(rename = "jobsQueues")]
1051 pub jobs_queues: f64,
1052 #[serde(rename = "kvResources")]
1053 pub kv_resources: f64,
1054 pub namespaces: Vec<String>,
1055 #[serde(rename = "natsPublish")]
1056 pub nats_publish: f64,
1057 #[serde(rename = "natsSubscribe")]
1058 pub nats_subscribe: f64,
1059 #[serde(rename = "rpcMethods")]
1060 pub rpc_methods: f64,
1061 #[serde(rename = "streamResources")]
1062 pub stream_resources: f64,
1063}
1064
1065#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1070pub struct AuthListInstalledContractsResponseContractsItemResourceBindingsJobsQueuesValuePayload {
1071 pub schema: String,
1072}
1073
1074#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1076pub struct AuthListInstalledContractsResponseContractsItemResourceBindingsJobsQueuesValueResult {
1077 pub schema: String,
1078}
1079
1080#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1081pub struct AuthListInstalledContractsResponseContractsItemResourceBindingsJobsQueuesValue {
1082 #[serde(rename = "ackWaitMs")]
1083 pub ack_wait_ms: i64,
1084 #[serde(rename = "backoffMs")]
1085 pub backoff_ms: Vec<i64>,
1086 pub concurrency: i64,
1087 #[serde(rename = "consumerName")]
1088 pub consumer_name: String,
1089 #[serde(rename = "defaultDeadlineMs")]
1090 #[serde(skip_serializing_if = "Option::is_none")]
1091 pub default_deadline_ms: Option<i64>,
1092 pub dlq: bool,
1093 pub logs: bool,
1094 #[serde(rename = "maxDeliver")]
1095 pub max_deliver: i64,
1096 pub payload: AuthListInstalledContractsResponseContractsItemResourceBindingsJobsQueuesValuePayload,
1097 pub progress: bool,
1098 #[serde(rename = "publishPrefix")]
1099 pub publish_prefix: String,
1100 #[serde(rename = "queueType")]
1101 pub queue_type: String,
1102 #[serde(skip_serializing_if = "Option::is_none")]
1103 pub result: Option<AuthListInstalledContractsResponseContractsItemResourceBindingsJobsQueuesValueResult>,
1104 #[serde(rename = "workSubject")]
1105 pub work_subject: String,
1106}
1107
1108#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1109pub struct AuthListInstalledContractsResponseContractsItemResourceBindingsJobs {
1110 pub namespace: String,
1111 pub queues: BTreeMap<String, AuthListInstalledContractsResponseContractsItemResourceBindingsJobsQueuesValue>,
1112}
1113
1114#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1116pub struct AuthListInstalledContractsResponseContractsItemResourceBindingsKvValue {
1117 pub bucket: String,
1118 pub history: i64,
1119 #[serde(rename = "maxValueBytes")]
1120 #[serde(skip_serializing_if = "Option::is_none")]
1121 pub max_value_bytes: Option<i64>,
1122 #[serde(rename = "ttlMs")]
1123 pub ttl_ms: i64,
1124}
1125
1126#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1129pub struct AuthListInstalledContractsResponseContractsItemResourceBindingsStreamsValueSourcesItem {
1130 #[serde(rename = "filterSubject")]
1131 #[serde(skip_serializing_if = "Option::is_none")]
1132 pub filter_subject: Option<String>,
1133 #[serde(rename = "fromAlias")]
1134 pub from_alias: String,
1135 #[serde(rename = "streamName")]
1136 pub stream_name: String,
1137 #[serde(rename = "subjectTransformDest")]
1138 #[serde(skip_serializing_if = "Option::is_none")]
1139 pub subject_transform_dest: Option<String>,
1140}
1141
1142#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1143pub struct AuthListInstalledContractsResponseContractsItemResourceBindingsStreamsValue {
1144 #[serde(skip_serializing_if = "Option::is_none")]
1145 pub discard: Option<String>,
1146 #[serde(rename = "maxAgeMs")]
1147 #[serde(skip_serializing_if = "Option::is_none")]
1148 pub max_age_ms: Option<i64>,
1149 #[serde(rename = "maxBytes")]
1150 #[serde(skip_serializing_if = "Option::is_none")]
1151 pub max_bytes: Option<i64>,
1152 #[serde(rename = "maxMsgs")]
1153 #[serde(skip_serializing_if = "Option::is_none")]
1154 pub max_msgs: Option<i64>,
1155 pub name: String,
1156 #[serde(rename = "numReplicas")]
1157 #[serde(skip_serializing_if = "Option::is_none")]
1158 pub num_replicas: Option<i64>,
1159 #[serde(skip_serializing_if = "Option::is_none")]
1160 pub retention: Option<String>,
1161 #[serde(skip_serializing_if = "Option::is_none")]
1162 pub sources: Option<Vec<AuthListInstalledContractsResponseContractsItemResourceBindingsStreamsValueSourcesItem>>,
1163 #[serde(skip_serializing_if = "Option::is_none")]
1164 pub storage: Option<String>,
1165 pub subjects: Vec<String>,
1166}
1167
1168#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1169pub struct AuthListInstalledContractsResponseContractsItemResourceBindings {
1170 #[serde(skip_serializing_if = "Option::is_none")]
1171 pub jobs: Option<AuthListInstalledContractsResponseContractsItemResourceBindingsJobs>,
1172 #[serde(skip_serializing_if = "Option::is_none")]
1173 pub kv: Option<BTreeMap<String, AuthListInstalledContractsResponseContractsItemResourceBindingsKvValue>>,
1174 #[serde(skip_serializing_if = "Option::is_none")]
1175 pub streams: Option<BTreeMap<String, AuthListInstalledContractsResponseContractsItemResourceBindingsStreamsValue>>,
1176}
1177
1178#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1179pub struct AuthListInstalledContractsResponseContractsItem {
1180 #[serde(rename = "analysisSummary")]
1181 #[serde(skip_serializing_if = "Option::is_none")]
1182 pub analysis_summary: Option<AuthListInstalledContractsResponseContractsItemAnalysisSummary>,
1183 pub description: String,
1184 pub digest: String,
1185 #[serde(rename = "displayName")]
1186 pub display_name: String,
1187 pub id: String,
1188 #[serde(rename = "installedAt")]
1189 pub installed_at: String,
1190 #[serde(rename = "resourceBindings")]
1191 #[serde(skip_serializing_if = "Option::is_none")]
1192 pub resource_bindings: Option<AuthListInstalledContractsResponseContractsItemResourceBindings>,
1193 #[serde(rename = "sessionKey")]
1194 #[serde(skip_serializing_if = "Option::is_none")]
1195 pub session_key: Option<String>,
1196}
1197
1198#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1199pub struct AuthListInstalledContractsResponse {
1200 pub contracts: Vec<AuthListInstalledContractsResponseContractsItem>,
1201}
1202
1203#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1206pub struct AuthListLoginPortalSelectionsResponseSelectionsItem {
1207 #[serde(rename = "contractId")]
1208 pub contract_id: String,
1209 #[serde(rename = "portalId")]
1210 pub portal_id: Value,
1211}
1212
1213#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1214pub struct AuthListLoginPortalSelectionsResponse {
1215 pub selections: Vec<AuthListLoginPortalSelectionsResponseSelectionsItem>,
1216}
1217
1218#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1221pub struct AuthListPortalsResponsePortalsItem {
1222 #[serde(rename = "appContractId")]
1223 #[serde(skip_serializing_if = "Option::is_none")]
1224 pub app_contract_id: Option<String>,
1225 pub disabled: bool,
1226 #[serde(rename = "entryUrl")]
1227 pub entry_url: String,
1228 #[serde(rename = "portalId")]
1229 pub portal_id: String,
1230}
1231
1232#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1233pub struct AuthListPortalsResponse {
1234 pub portals: Vec<AuthListPortalsResponsePortalsItem>,
1235}
1236
1237#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1244pub struct AuthListServicesResponseServicesItemResourceBindingsJobsQueuesValuePayload {
1245 pub schema: String,
1246}
1247
1248#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1250pub struct AuthListServicesResponseServicesItemResourceBindingsJobsQueuesValueResult {
1251 pub schema: String,
1252}
1253
1254#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1255pub struct AuthListServicesResponseServicesItemResourceBindingsJobsQueuesValue {
1256 #[serde(rename = "ackWaitMs")]
1257 pub ack_wait_ms: i64,
1258 #[serde(rename = "backoffMs")]
1259 pub backoff_ms: Vec<i64>,
1260 pub concurrency: i64,
1261 #[serde(rename = "consumerName")]
1262 pub consumer_name: String,
1263 #[serde(rename = "defaultDeadlineMs")]
1264 #[serde(skip_serializing_if = "Option::is_none")]
1265 pub default_deadline_ms: Option<i64>,
1266 pub dlq: bool,
1267 pub logs: bool,
1268 #[serde(rename = "maxDeliver")]
1269 pub max_deliver: i64,
1270 pub payload: AuthListServicesResponseServicesItemResourceBindingsJobsQueuesValuePayload,
1271 pub progress: bool,
1272 #[serde(rename = "publishPrefix")]
1273 pub publish_prefix: String,
1274 #[serde(rename = "queueType")]
1275 pub queue_type: String,
1276 #[serde(skip_serializing_if = "Option::is_none")]
1277 pub result: Option<AuthListServicesResponseServicesItemResourceBindingsJobsQueuesValueResult>,
1278 #[serde(rename = "workSubject")]
1279 pub work_subject: String,
1280}
1281
1282#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1283pub struct AuthListServicesResponseServicesItemResourceBindingsJobs {
1284 pub namespace: String,
1285 pub queues: BTreeMap<String, AuthListServicesResponseServicesItemResourceBindingsJobsQueuesValue>,
1286}
1287
1288#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1290pub struct AuthListServicesResponseServicesItemResourceBindingsKvValue {
1291 pub bucket: String,
1292 pub history: i64,
1293 #[serde(rename = "maxValueBytes")]
1294 #[serde(skip_serializing_if = "Option::is_none")]
1295 pub max_value_bytes: Option<i64>,
1296 #[serde(rename = "ttlMs")]
1297 pub ttl_ms: i64,
1298}
1299
1300#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1303pub struct AuthListServicesResponseServicesItemResourceBindingsStreamsValueSourcesItem {
1304 #[serde(rename = "filterSubject")]
1305 #[serde(skip_serializing_if = "Option::is_none")]
1306 pub filter_subject: Option<String>,
1307 #[serde(rename = "fromAlias")]
1308 pub from_alias: String,
1309 #[serde(rename = "streamName")]
1310 pub stream_name: String,
1311 #[serde(rename = "subjectTransformDest")]
1312 #[serde(skip_serializing_if = "Option::is_none")]
1313 pub subject_transform_dest: Option<String>,
1314}
1315
1316#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1317pub struct AuthListServicesResponseServicesItemResourceBindingsStreamsValue {
1318 #[serde(skip_serializing_if = "Option::is_none")]
1319 pub discard: Option<String>,
1320 #[serde(rename = "maxAgeMs")]
1321 #[serde(skip_serializing_if = "Option::is_none")]
1322 pub max_age_ms: Option<i64>,
1323 #[serde(rename = "maxBytes")]
1324 #[serde(skip_serializing_if = "Option::is_none")]
1325 pub max_bytes: Option<i64>,
1326 #[serde(rename = "maxMsgs")]
1327 #[serde(skip_serializing_if = "Option::is_none")]
1328 pub max_msgs: Option<i64>,
1329 pub name: String,
1330 #[serde(rename = "numReplicas")]
1331 #[serde(skip_serializing_if = "Option::is_none")]
1332 pub num_replicas: Option<i64>,
1333 #[serde(skip_serializing_if = "Option::is_none")]
1334 pub retention: Option<String>,
1335 #[serde(skip_serializing_if = "Option::is_none")]
1336 pub sources: Option<Vec<AuthListServicesResponseServicesItemResourceBindingsStreamsValueSourcesItem>>,
1337 #[serde(skip_serializing_if = "Option::is_none")]
1338 pub storage: Option<String>,
1339 pub subjects: Vec<String>,
1340}
1341
1342#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1343pub struct AuthListServicesResponseServicesItemResourceBindings {
1344 #[serde(skip_serializing_if = "Option::is_none")]
1345 pub jobs: Option<AuthListServicesResponseServicesItemResourceBindingsJobs>,
1346 #[serde(skip_serializing_if = "Option::is_none")]
1347 pub kv: Option<BTreeMap<String, AuthListServicesResponseServicesItemResourceBindingsKvValue>>,
1348 #[serde(skip_serializing_if = "Option::is_none")]
1349 pub streams: Option<BTreeMap<String, AuthListServicesResponseServicesItemResourceBindingsStreamsValue>>,
1350}
1351
1352#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1353pub struct AuthListServicesResponseServicesItem {
1354 pub active: bool,
1355 pub capabilities: Vec<String>,
1356 #[serde(rename = "contractDigest")]
1357 #[serde(skip_serializing_if = "Option::is_none")]
1358 pub contract_digest: Option<String>,
1359 #[serde(rename = "contractId")]
1360 #[serde(skip_serializing_if = "Option::is_none")]
1361 pub contract_id: Option<String>,
1362 #[serde(rename = "createdAt")]
1363 pub created_at: String,
1364 pub description: String,
1365 #[serde(rename = "displayName")]
1366 pub display_name: String,
1367 pub namespaces: Vec<String>,
1368 #[serde(rename = "resourceBindings")]
1369 #[serde(skip_serializing_if = "Option::is_none")]
1370 pub resource_bindings: Option<AuthListServicesResponseServicesItemResourceBindings>,
1371 #[serde(rename = "sessionKey")]
1372 pub session_key: String,
1373}
1374
1375#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1376pub struct AuthListServicesResponse {
1377 pub services: Vec<AuthListServicesResponseServicesItem>,
1378}
1379
1380#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1382pub struct AuthListSessionsRequest {
1383 #[serde(skip_serializing_if = "Option::is_none")]
1384 pub user: Option<String>,
1385}
1386
1387#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1390pub struct AuthListSessionsResponseSessionsItem {
1391 #[serde(rename = "createdAt")]
1392 pub created_at: String,
1393 pub key: String,
1394 #[serde(rename = "lastAuth")]
1395 pub last_auth: String,
1396 pub r#type: Value,
1397}
1398
1399#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1400pub struct AuthListSessionsResponse {
1401 pub sessions: Vec<AuthListSessionsResponseSessionsItem>,
1402}
1403
1404#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1407pub struct AuthListUsersResponseUsersItem {
1408 pub active: bool,
1409 pub capabilities: Vec<String>,
1410 #[serde(skip_serializing_if = "Option::is_none")]
1411 pub email: Option<String>,
1412 pub id: String,
1413 #[serde(skip_serializing_if = "Option::is_none")]
1414 pub name: Option<String>,
1415 pub origin: String,
1416}
1417
1418#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1419pub struct AuthListUsersResponse {
1420 pub users: Vec<AuthListUsersResponseUsersItem>,
1421}
1422
1423#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1425pub struct AuthListWorkloadActivationReviewsRequest {
1426 #[serde(rename = "instanceId")]
1427 #[serde(skip_serializing_if = "Option::is_none")]
1428 pub instance_id: Option<String>,
1429 #[serde(rename = "profileId")]
1430 #[serde(skip_serializing_if = "Option::is_none")]
1431 pub profile_id: Option<String>,
1432 #[serde(skip_serializing_if = "Option::is_none")]
1433 pub state: Option<Value>,
1434}
1435
1436#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1439pub struct AuthListWorkloadActivationReviewsResponseReviewsItem {
1440 #[serde(rename = "decidedAt")]
1441 pub decided_at: Value,
1442 #[serde(rename = "instanceId")]
1443 pub instance_id: String,
1444 #[serde(rename = "profileId")]
1445 pub profile_id: String,
1446 #[serde(rename = "publicIdentityKey")]
1447 pub public_identity_key: String,
1448 #[serde(skip_serializing_if = "Option::is_none")]
1449 pub reason: Option<String>,
1450 #[serde(rename = "requestedAt")]
1451 pub requested_at: String,
1452 #[serde(rename = "reviewId")]
1453 pub review_id: String,
1454 pub state: Value,
1455}
1456
1457#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1458pub struct AuthListWorkloadActivationReviewsResponse {
1459 pub reviews: Vec<AuthListWorkloadActivationReviewsResponseReviewsItem>,
1460}
1461
1462#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1464pub struct AuthListWorkloadActivationsRequest {
1465 #[serde(rename = "instanceId")]
1466 #[serde(skip_serializing_if = "Option::is_none")]
1467 pub instance_id: Option<String>,
1468 #[serde(rename = "profileId")]
1469 #[serde(skip_serializing_if = "Option::is_none")]
1470 pub profile_id: Option<String>,
1471 #[serde(skip_serializing_if = "Option::is_none")]
1472 pub state: Option<Value>,
1473}
1474
1475#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1479pub struct AuthListWorkloadActivationsResponseActivationsItemActivatedBy {
1480 pub id: String,
1481 pub origin: String,
1482}
1483
1484#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1485pub struct AuthListWorkloadActivationsResponseActivationsItem {
1486 #[serde(rename = "activatedAt")]
1487 pub activated_at: String,
1488 #[serde(rename = "activatedBy")]
1489 #[serde(skip_serializing_if = "Option::is_none")]
1490 pub activated_by: Option<AuthListWorkloadActivationsResponseActivationsItemActivatedBy>,
1491 #[serde(rename = "instanceId")]
1492 pub instance_id: String,
1493 #[serde(rename = "profileId")]
1494 pub profile_id: String,
1495 #[serde(rename = "publicIdentityKey")]
1496 pub public_identity_key: String,
1497 #[serde(rename = "revokedAt")]
1498 pub revoked_at: Value,
1499 pub state: Value,
1500}
1501
1502#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1503pub struct AuthListWorkloadActivationsResponse {
1504 pub activations: Vec<AuthListWorkloadActivationsResponseActivationsItem>,
1505}
1506
1507#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1509pub struct AuthListWorkloadInstancesRequest {
1510 #[serde(rename = "profileId")]
1511 #[serde(skip_serializing_if = "Option::is_none")]
1512 pub profile_id: Option<String>,
1513 #[serde(skip_serializing_if = "Option::is_none")]
1514 pub state: Option<Value>,
1515}
1516
1517#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1520pub struct AuthListWorkloadInstancesResponseInstancesItem {
1521 #[serde(rename = "activatedAt")]
1522 pub activated_at: Value,
1523 #[serde(rename = "createdAt")]
1524 pub created_at: String,
1525 #[serde(rename = "instanceId")]
1526 pub instance_id: String,
1527 #[serde(rename = "profileId")]
1528 pub profile_id: String,
1529 #[serde(rename = "publicIdentityKey")]
1530 pub public_identity_key: String,
1531 #[serde(rename = "revokedAt")]
1532 pub revoked_at: Value,
1533 pub state: Value,
1534}
1535
1536#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1537pub struct AuthListWorkloadInstancesResponse {
1538 pub instances: Vec<AuthListWorkloadInstancesResponseInstancesItem>,
1539}
1540
1541#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1544pub struct AuthListWorkloadPortalSelectionsResponseSelectionsItem {
1545 #[serde(rename = "portalId")]
1546 pub portal_id: Value,
1547 #[serde(rename = "profileId")]
1548 pub profile_id: String,
1549}
1550
1551#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1552pub struct AuthListWorkloadPortalSelectionsResponse {
1553 pub selections: Vec<AuthListWorkloadPortalSelectionsResponseSelectionsItem>,
1554}
1555
1556#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1558pub struct AuthListWorkloadProfilesRequest {
1559 #[serde(rename = "contractId")]
1560 #[serde(skip_serializing_if = "Option::is_none")]
1561 pub contract_id: Option<String>,
1562 #[serde(skip_serializing_if = "Option::is_none")]
1563 pub disabled: Option<bool>,
1564}
1565
1566#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1569pub struct AuthListWorkloadProfilesResponseProfilesItem {
1570 #[serde(rename = "allowedDigests")]
1571 pub allowed_digests: Vec<String>,
1572 #[serde(rename = "contractId")]
1573 pub contract_id: String,
1574 pub disabled: bool,
1575 #[serde(rename = "profileId")]
1576 pub profile_id: String,
1577 #[serde(rename = "reviewMode")]
1578 #[serde(skip_serializing_if = "Option::is_none")]
1579 pub review_mode: Option<Value>,
1580}
1581
1582#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1583pub struct AuthListWorkloadProfilesResponse {
1584 pub profiles: Vec<AuthListWorkloadProfilesResponseProfilesItem>,
1585}
1586
1587#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1589pub struct AuthLogoutResponse {
1590 pub success: bool,
1591}
1592
1593#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1595pub struct AuthMeResponse {
1596 pub service: Value,
1597 pub user: Value,
1598 pub workload: Value,
1599}
1600
1601#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1603pub struct AuthProvisionWorkloadInstanceRequest {
1604 #[serde(rename = "activationKey")]
1605 pub activation_key: String,
1606 #[serde(rename = "profileId")]
1607 pub profile_id: String,
1608 #[serde(rename = "publicIdentityKey")]
1609 pub public_identity_key: String,
1610}
1611
1612#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1615pub struct AuthProvisionWorkloadInstanceResponseInstance {
1616 #[serde(rename = "activatedAt")]
1617 pub activated_at: Value,
1618 #[serde(rename = "createdAt")]
1619 pub created_at: String,
1620 #[serde(rename = "instanceId")]
1621 pub instance_id: String,
1622 #[serde(rename = "profileId")]
1623 pub profile_id: String,
1624 #[serde(rename = "publicIdentityKey")]
1625 pub public_identity_key: String,
1626 #[serde(rename = "revokedAt")]
1627 pub revoked_at: Value,
1628 pub state: Value,
1629}
1630
1631#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1632pub struct AuthProvisionWorkloadInstanceResponse {
1633 pub instance: AuthProvisionWorkloadInstanceResponseInstance,
1634}
1635
1636#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1639pub struct AuthRenewBindingTokenResponseSentinel {
1640 pub jwt: String,
1641 pub seed: String,
1642}
1643
1644#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1645pub struct AuthRenewBindingTokenResponse {
1646 #[serde(rename = "bindingToken")]
1647 pub binding_token: String,
1648 pub expires: String,
1649 #[serde(rename = "inboxPrefix")]
1650 pub inbox_prefix: String,
1651 #[serde(rename = "natsServers")]
1652 pub nats_servers: Vec<String>,
1653 pub sentinel: AuthRenewBindingTokenResponseSentinel,
1654 pub status: String,
1655}
1656
1657#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1659pub struct AuthRevokeApprovalRequest {
1660 #[serde(rename = "contractDigest")]
1661 pub contract_digest: String,
1662 #[serde(skip_serializing_if = "Option::is_none")]
1663 pub user: Option<String>,
1664}
1665
1666#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1668pub struct AuthRevokeApprovalResponse {
1669 pub success: bool,
1670}
1671
1672#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1674pub struct AuthRevokeSessionRequest {
1675 #[serde(rename = "sessionKey")]
1676 pub session_key: String,
1677}
1678
1679#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1681pub struct AuthRevokeSessionResponse {
1682 pub success: bool,
1683}
1684
1685#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1687pub struct AuthRevokeWorkloadActivationRequest {
1688 #[serde(rename = "instanceId")]
1689 pub instance_id: String,
1690}
1691
1692#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1694pub struct AuthRevokeWorkloadActivationResponse {
1695 pub success: bool,
1696}
1697
1698#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1700pub struct AuthSetLoginPortalDefaultRequest {
1701 #[serde(rename = "portalId")]
1702 pub portal_id: Value,
1703}
1704
1705#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1708pub struct AuthSetLoginPortalDefaultResponseDefaultPortal {
1709 #[serde(rename = "portalId")]
1710 pub portal_id: Value,
1711}
1712
1713#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1714pub struct AuthSetLoginPortalDefaultResponse {
1715 #[serde(rename = "defaultPortal")]
1716 pub default_portal: AuthSetLoginPortalDefaultResponseDefaultPortal,
1717}
1718
1719#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1721pub struct AuthSetLoginPortalSelectionRequest {
1722 #[serde(rename = "contractId")]
1723 pub contract_id: String,
1724 #[serde(rename = "portalId")]
1725 pub portal_id: Value,
1726}
1727
1728#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1731pub struct AuthSetLoginPortalSelectionResponseSelection {
1732 #[serde(rename = "contractId")]
1733 pub contract_id: String,
1734 #[serde(rename = "portalId")]
1735 pub portal_id: Value,
1736}
1737
1738#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1739pub struct AuthSetLoginPortalSelectionResponse {
1740 pub selection: AuthSetLoginPortalSelectionResponseSelection,
1741}
1742
1743#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1745pub struct AuthSetWorkloadPortalDefaultRequest {
1746 #[serde(rename = "portalId")]
1747 pub portal_id: Value,
1748}
1749
1750#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1753pub struct AuthSetWorkloadPortalDefaultResponseDefaultPortal {
1754 #[serde(rename = "portalId")]
1755 pub portal_id: Value,
1756}
1757
1758#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1759pub struct AuthSetWorkloadPortalDefaultResponse {
1760 #[serde(rename = "defaultPortal")]
1761 pub default_portal: AuthSetWorkloadPortalDefaultResponseDefaultPortal,
1762}
1763
1764#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1766pub struct AuthSetWorkloadPortalSelectionRequest {
1767 #[serde(rename = "portalId")]
1768 pub portal_id: Value,
1769 #[serde(rename = "profileId")]
1770 pub profile_id: String,
1771}
1772
1773#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1776pub struct AuthSetWorkloadPortalSelectionResponseSelection {
1777 #[serde(rename = "portalId")]
1778 pub portal_id: Value,
1779 #[serde(rename = "profileId")]
1780 pub profile_id: String,
1781}
1782
1783#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1784pub struct AuthSetWorkloadPortalSelectionResponse {
1785 pub selection: AuthSetWorkloadPortalSelectionResponseSelection,
1786}
1787
1788#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1790pub struct AuthUpdateUserRequest {
1791 #[serde(skip_serializing_if = "Option::is_none")]
1792 pub active: Option<bool>,
1793 #[serde(skip_serializing_if = "Option::is_none")]
1794 pub capabilities: Option<Vec<String>>,
1795 pub id: String,
1796 pub origin: String,
1797}
1798
1799#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1801pub struct AuthUpdateUserResponse {
1802 pub success: bool,
1803}
1804
1805#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1807pub struct AuthUpgradeServiceContractRequest {
1808 pub contract: BTreeMap<String, Value>,
1809 #[serde(rename = "sessionKey")]
1810 pub session_key: String,
1811}
1812
1813#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1819pub struct AuthUpgradeServiceContractResponseResourceBindingsJobsQueuesValuePayload {
1820 pub schema: String,
1821}
1822
1823#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1825pub struct AuthUpgradeServiceContractResponseResourceBindingsJobsQueuesValueResult {
1826 pub schema: String,
1827}
1828
1829#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1830pub struct AuthUpgradeServiceContractResponseResourceBindingsJobsQueuesValue {
1831 #[serde(rename = "ackWaitMs")]
1832 pub ack_wait_ms: i64,
1833 #[serde(rename = "backoffMs")]
1834 pub backoff_ms: Vec<i64>,
1835 pub concurrency: i64,
1836 #[serde(rename = "consumerName")]
1837 pub consumer_name: String,
1838 #[serde(rename = "defaultDeadlineMs")]
1839 #[serde(skip_serializing_if = "Option::is_none")]
1840 pub default_deadline_ms: Option<i64>,
1841 pub dlq: bool,
1842 pub logs: bool,
1843 #[serde(rename = "maxDeliver")]
1844 pub max_deliver: i64,
1845 pub payload: AuthUpgradeServiceContractResponseResourceBindingsJobsQueuesValuePayload,
1846 pub progress: bool,
1847 #[serde(rename = "publishPrefix")]
1848 pub publish_prefix: String,
1849 #[serde(rename = "queueType")]
1850 pub queue_type: String,
1851 #[serde(skip_serializing_if = "Option::is_none")]
1852 pub result: Option<AuthUpgradeServiceContractResponseResourceBindingsJobsQueuesValueResult>,
1853 #[serde(rename = "workSubject")]
1854 pub work_subject: String,
1855}
1856
1857#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1858pub struct AuthUpgradeServiceContractResponseResourceBindingsJobs {
1859 pub namespace: String,
1860 pub queues: BTreeMap<String, AuthUpgradeServiceContractResponseResourceBindingsJobsQueuesValue>,
1861}
1862
1863#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1865pub struct AuthUpgradeServiceContractResponseResourceBindingsKvValue {
1866 pub bucket: String,
1867 pub history: i64,
1868 #[serde(rename = "maxValueBytes")]
1869 #[serde(skip_serializing_if = "Option::is_none")]
1870 pub max_value_bytes: Option<i64>,
1871 #[serde(rename = "ttlMs")]
1872 pub ttl_ms: i64,
1873}
1874
1875#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1878pub struct AuthUpgradeServiceContractResponseResourceBindingsStreamsValueSourcesItem {
1879 #[serde(rename = "filterSubject")]
1880 #[serde(skip_serializing_if = "Option::is_none")]
1881 pub filter_subject: Option<String>,
1882 #[serde(rename = "fromAlias")]
1883 pub from_alias: String,
1884 #[serde(rename = "streamName")]
1885 pub stream_name: String,
1886 #[serde(rename = "subjectTransformDest")]
1887 #[serde(skip_serializing_if = "Option::is_none")]
1888 pub subject_transform_dest: Option<String>,
1889}
1890
1891#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1892pub struct AuthUpgradeServiceContractResponseResourceBindingsStreamsValue {
1893 #[serde(skip_serializing_if = "Option::is_none")]
1894 pub discard: Option<String>,
1895 #[serde(rename = "maxAgeMs")]
1896 #[serde(skip_serializing_if = "Option::is_none")]
1897 pub max_age_ms: Option<i64>,
1898 #[serde(rename = "maxBytes")]
1899 #[serde(skip_serializing_if = "Option::is_none")]
1900 pub max_bytes: Option<i64>,
1901 #[serde(rename = "maxMsgs")]
1902 #[serde(skip_serializing_if = "Option::is_none")]
1903 pub max_msgs: Option<i64>,
1904 pub name: String,
1905 #[serde(rename = "numReplicas")]
1906 #[serde(skip_serializing_if = "Option::is_none")]
1907 pub num_replicas: Option<i64>,
1908 #[serde(skip_serializing_if = "Option::is_none")]
1909 pub retention: Option<String>,
1910 #[serde(skip_serializing_if = "Option::is_none")]
1911 pub sources: Option<Vec<AuthUpgradeServiceContractResponseResourceBindingsStreamsValueSourcesItem>>,
1912 #[serde(skip_serializing_if = "Option::is_none")]
1913 pub storage: Option<String>,
1914 pub subjects: Vec<String>,
1915}
1916
1917#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1918pub struct AuthUpgradeServiceContractResponseResourceBindings {
1919 #[serde(skip_serializing_if = "Option::is_none")]
1920 pub jobs: Option<AuthUpgradeServiceContractResponseResourceBindingsJobs>,
1921 #[serde(skip_serializing_if = "Option::is_none")]
1922 pub kv: Option<BTreeMap<String, AuthUpgradeServiceContractResponseResourceBindingsKvValue>>,
1923 #[serde(skip_serializing_if = "Option::is_none")]
1924 pub streams: Option<BTreeMap<String, AuthUpgradeServiceContractResponseResourceBindingsStreamsValue>>,
1925}
1926
1927#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1928pub struct AuthUpgradeServiceContractResponse {
1929 #[serde(rename = "contractDigest")]
1930 pub contract_digest: String,
1931 #[serde(rename = "contractId")]
1932 pub contract_id: String,
1933 #[serde(rename = "resourceBindings")]
1934 pub resource_bindings: AuthUpgradeServiceContractResponseResourceBindings,
1935 #[serde(rename = "sessionKey")]
1936 pub session_key: String,
1937 pub success: bool,
1938}
1939
1940#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1942pub struct AuthValidateRequestRequest {
1943 #[serde(skip_serializing_if = "Option::is_none")]
1944 pub capabilities: Option<Vec<String>>,
1945 #[serde(rename = "payloadHash")]
1946 pub payload_hash: String,
1947 pub proof: String,
1948 #[serde(rename = "sessionKey")]
1949 pub session_key: String,
1950 pub subject: String,
1951}
1952
1953#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1955pub struct AuthValidateRequestResponse {
1956 pub allowed: bool,
1957 pub caller: Value,
1958 #[serde(rename = "inboxPrefix")]
1959 pub inbox_prefix: String,
1960}
1961
1962#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1964pub struct AuthConnectEvent(pub Value);
1965
1966#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1968pub struct AuthConnectionKickedEvent(pub Value);
1969
1970#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1972pub struct AuthDisconnectEvent(pub Value);
1973
1974#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1976pub struct AuthSessionRevokedEvent(pub Value);
1977
1978#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1981pub struct AuthWorkloadActivationReviewRequestedEventRequestedBy {
1982 pub id: String,
1983 pub origin: String,
1984}
1985
1986#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1987pub struct AuthWorkloadActivationReviewRequestedEvent {
1988 #[serde(rename = "handoffId")]
1989 pub handoff_id: String,
1990 #[serde(rename = "instanceId")]
1991 pub instance_id: String,
1992 #[serde(rename = "profileId")]
1993 pub profile_id: String,
1994 #[serde(rename = "publicIdentityKey")]
1995 pub public_identity_key: String,
1996 #[serde(rename = "requestedAt")]
1997 pub requested_at: String,
1998 #[serde(rename = "requestedBy")]
1999 pub requested_by: AuthWorkloadActivationReviewRequestedEventRequestedBy,
2000 #[serde(rename = "reviewId")]
2001 pub review_id: String,
2002}
2003