1use num_enum::{IntoPrimitive, TryFromPrimitive};
11use proptest_derive::Arbitrary;
12use serde::{Deserialize, Serialize};
13
14#[derive(
15 Clone,
16 Debug,
17 Default,
18 PartialEq,
19 Eq,
20 PartialOrd,
21 Ord,
22 Serialize,
23 Deserialize,
24 Arbitrary
25)]
26pub struct ConfigKey {
27 pub key: String,
28}
29
30#[derive(
31 Clone,
32 Copy,
33 Debug,
34 Default,
35 PartialEq,
36 Eq,
37 PartialOrd,
38 Ord,
39 Serialize,
40 Deserialize,
41 Arbitrary
42)]
43pub struct ConfigValue {
44 pub value: u64,
45}
46
47#[derive(
48 Clone,
49 Debug,
50 Default,
51 PartialEq,
52 Eq,
53 PartialOrd,
54 Ord,
55 Serialize,
56 Deserialize,
57 Arbitrary
58)]
59pub struct SettingKey {
60 pub name: String,
61}
62
63#[derive(
64 Clone,
65 Debug,
66 Default,
67 PartialEq,
68 Eq,
69 PartialOrd,
70 Ord,
71 Serialize,
72 Deserialize,
73 Arbitrary
74)]
75pub struct SettingValue {
76 pub value: String,
77}
78
79#[derive(
80 Clone,
81 Debug,
82 Default,
83 PartialEq,
84 Eq,
85 PartialOrd,
86 Ord,
87 Serialize,
88 Deserialize,
89 Arbitrary
90)]
91pub struct IdAllocKey {
92 pub name: String,
93}
94
95#[derive(
96 Clone,
97 Copy,
98 Debug,
99 Default,
100 PartialEq,
101 Eq,
102 PartialOrd,
103 Ord,
104 Serialize,
105 Deserialize,
106 Arbitrary
107)]
108pub struct IdAllocValue {
109 pub next_id: u64,
110}
111
112#[derive(
113 Clone,
114 Debug,
115 Default,
116 PartialEq,
117 Eq,
118 PartialOrd,
119 Ord,
120 Serialize,
121 Deserialize,
122 Arbitrary
123)]
124pub struct GidMappingKey {
125 pub schema_name: String,
126 pub object_type: i32,
127 pub object_name: String,
128}
129
130#[derive(
131 Clone,
132 Debug,
133 Default,
134 PartialEq,
135 Eq,
136 PartialOrd,
137 Ord,
138 Serialize,
139 Deserialize,
140 Arbitrary
141)]
142pub struct GidMappingValue {
143 pub id: u64,
144 pub fingerprint: String,
145 pub global_id: Option<SystemGlobalId>,
146}
147
148#[derive(
149 Clone,
150 Copy,
151 Debug,
152 Default,
153 PartialEq,
154 Eq,
155 PartialOrd,
156 Ord,
157 Serialize,
158 Deserialize,
159 Arbitrary
160)]
161pub struct ClusterKey {
162 pub id: Option<ClusterId>,
163}
164
165#[derive(
166 Clone,
167 Debug,
168 Default,
169 PartialEq,
170 Eq,
171 PartialOrd,
172 Ord,
173 Serialize,
174 Deserialize,
175 Arbitrary
176)]
177pub struct ClusterValue {
178 pub name: String,
179 pub owner_id: Option<RoleId>,
180 pub privileges: Vec<MzAclItem>,
181 pub config: Option<ClusterConfig>,
182}
183
184#[derive(
185 Clone,
186 Debug,
187 Default,
188 PartialEq,
189 Eq,
190 PartialOrd,
191 Ord,
192 Serialize,
193 Deserialize,
194 Arbitrary
195)]
196pub struct ClusterIntrospectionSourceIndexKey {
197 pub cluster_id: Option<ClusterId>,
198 pub name: String,
199}
200
201#[derive(
202 Clone,
203 Copy,
204 Debug,
205 Default,
206 PartialEq,
207 Eq,
208 PartialOrd,
209 Ord,
210 Serialize,
211 Deserialize,
212 Arbitrary
213)]
214pub struct ClusterIntrospectionSourceIndexValue {
215 pub index_id: u64,
216 pub oid: u32,
217 pub global_id: Option<IntrospectionSourceIndexGlobalId>,
218}
219
220#[derive(
221 Clone,
222 Copy,
223 Debug,
224 Default,
225 PartialEq,
226 Eq,
227 PartialOrd,
228 Ord,
229 Serialize,
230 Deserialize,
231 Arbitrary
232)]
233pub struct ClusterReplicaKey {
234 pub id: Option<ReplicaId>,
235}
236
237#[derive(
238 Clone,
239 Debug,
240 Default,
241 PartialEq,
242 Eq,
243 PartialOrd,
244 Ord,
245 Serialize,
246 Deserialize,
247 Arbitrary
248)]
249pub struct ClusterReplicaValue {
250 pub cluster_id: Option<ClusterId>,
251 pub name: String,
252 pub config: Option<ReplicaConfig>,
253 pub owner_id: Option<RoleId>,
254}
255
256#[derive(
257 Clone,
258 Copy,
259 Debug,
260 Default,
261 PartialEq,
262 Eq,
263 PartialOrd,
264 Ord,
265 Serialize,
266 Deserialize,
267 Arbitrary
268)]
269pub struct DatabaseKey {
270 pub id: Option<DatabaseId>,
271}
272
273#[derive(
274 Clone,
275 Debug,
276 Default,
277 PartialEq,
278 Eq,
279 PartialOrd,
280 Ord,
281 Serialize,
282 Deserialize,
283 Arbitrary
284)]
285pub struct DatabaseValue {
286 pub name: String,
287 pub owner_id: Option<RoleId>,
288 pub privileges: Vec<MzAclItem>,
289 pub oid: u32,
290}
291
292#[derive(
293 Clone,
294 Copy,
295 Debug,
296 Default,
297 PartialEq,
298 Eq,
299 PartialOrd,
300 Ord,
301 Serialize,
302 Deserialize,
303 Arbitrary
304)]
305pub struct SchemaKey {
306 pub id: Option<SchemaId>,
307}
308
309#[derive(
310 Clone,
311 Debug,
312 Default,
313 PartialEq,
314 Eq,
315 PartialOrd,
316 Ord,
317 Serialize,
318 Deserialize,
319 Arbitrary
320)]
321pub struct SchemaValue {
322 pub database_id: Option<DatabaseId>,
323 pub name: String,
324 pub owner_id: Option<RoleId>,
325 pub privileges: Vec<MzAclItem>,
326 pub oid: u32,
327}
328
329#[derive(
330 Clone,
331 Copy,
332 Debug,
333 Default,
334 PartialEq,
335 Eq,
336 PartialOrd,
337 Ord,
338 Serialize,
339 Deserialize,
340 Arbitrary
341)]
342pub struct ItemKey {
343 pub gid: Option<CatalogItemId>,
344}
345
346#[derive(
347 Clone,
348 Debug,
349 Default,
350 PartialEq,
351 Eq,
352 PartialOrd,
353 Ord,
354 Serialize,
355 Deserialize,
356 Arbitrary
357)]
358pub struct ItemValue {
359 pub schema_id: Option<SchemaId>,
360 pub name: String,
361 pub definition: Option<CatalogItem>,
362 pub owner_id: Option<RoleId>,
363 pub privileges: Vec<MzAclItem>,
364 pub oid: u32,
365 pub global_id: Option<GlobalId>,
366 pub extra_versions: Vec<ItemVersion>,
367}
368
369#[derive(
370 Clone,
371 Copy,
372 Debug,
373 Default,
374 PartialEq,
375 Eq,
376 PartialOrd,
377 Ord,
378 Serialize,
379 Deserialize,
380 Arbitrary
381)]
382pub struct ItemVersion {
383 pub global_id: Option<GlobalId>,
384 pub version: Option<Version>,
385}
386
387#[derive(
388 Clone,
389 Copy,
390 Debug,
391 Default,
392 PartialEq,
393 Eq,
394 PartialOrd,
395 Ord,
396 Serialize,
397 Deserialize,
398 Arbitrary
399)]
400pub struct RoleKey {
401 pub id: Option<RoleId>,
402}
403
404#[derive(
405 Clone,
406 Debug,
407 Default,
408 PartialEq,
409 Eq,
410 PartialOrd,
411 Ord,
412 Serialize,
413 Deserialize,
414 Arbitrary
415)]
416pub struct RoleValue {
417 pub name: String,
418 pub attributes: Option<RoleAttributes>,
419 pub membership: Option<RoleMembership>,
420 pub vars: Option<RoleVars>,
421 pub oid: u32,
422}
423
424#[derive(
425 Clone,
426 Copy,
427 Debug,
428 Default,
429 PartialEq,
430 Eq,
431 PartialOrd,
432 Ord,
433 Serialize,
434 Deserialize,
435 Arbitrary
436)]
437pub struct RoleAuthKey {
438 pub id: Option<RoleId>,
439}
440
441#[derive(
442 Clone,
443 Debug,
444 Default,
445 PartialEq,
446 Eq,
447 PartialOrd,
448 Ord,
449 Serialize,
450 Deserialize,
451 Arbitrary
452)]
453pub struct RoleAuthValue {
454 pub password_hash: Option<String>,
455 #[proptest(filter = "Option::is_some")]
456 pub updated_at: Option<EpochMillis>,
457}
458
459#[derive(
460 Clone,
461 Copy,
462 Debug,
463 Default,
464 PartialEq,
465 Eq,
466 PartialOrd,
467 Ord,
468 Serialize,
469 Deserialize,
470 Arbitrary
471)]
472pub struct NetworkPolicyKey {
473 pub id: Option<NetworkPolicyId>,
474}
475
476#[derive(
477 Clone,
478 Debug,
479 Default,
480 PartialEq,
481 Eq,
482 PartialOrd,
483 Ord,
484 Serialize,
485 Deserialize,
486 Arbitrary
487)]
488pub struct NetworkPolicyValue {
489 pub name: String,
490 pub rules: Vec<NetworkPolicyRule>,
491 pub owner_id: Option<RoleId>,
492 pub privileges: Vec<MzAclItem>,
493 pub oid: u32,
494}
495
496#[derive(
497 Clone,
498 Debug,
499 Default,
500 PartialEq,
501 Eq,
502 PartialOrd,
503 Ord,
504 Serialize,
505 Deserialize,
506 Arbitrary
507)]
508pub struct ServerConfigurationKey {
509 pub name: String,
510}
511
512#[derive(
513 Clone,
514 Debug,
515 Default,
516 PartialEq,
517 Eq,
518 PartialOrd,
519 Ord,
520 Serialize,
521 Deserialize,
522 Arbitrary
523)]
524pub struct ServerConfigurationValue {
525 pub value: String,
526}
527
528#[derive(
529 Clone,
530 Debug,
531 Default,
532 PartialEq,
533 Eq,
534 PartialOrd,
535 Ord,
536 Serialize,
537 Deserialize,
538 Arbitrary
539)]
540pub struct AuditLogKey {
541 #[proptest(filter = "Option::is_some")]
542 pub event: Option<audit_log_key::Event>,
543}
544
545pub mod audit_log_key {
546 use super::*;
547
548 #[derive(
549 Clone,
550 Debug,
551 PartialEq,
552 Eq,
553 PartialOrd,
554 Ord,
555 Serialize,
556 Deserialize,
557 Arbitrary
558 )]
559 pub enum Event {
560 V1(AuditLogEventV1),
561 }
562}
563
564#[derive(
565 Clone,
566 Copy,
567 Debug,
568 Default,
569 PartialEq,
570 Eq,
571 PartialOrd,
572 Ord,
573 Serialize,
574 Deserialize,
575 Arbitrary
576)]
577pub struct CommentKey {
578 pub object: Option<comment_key::Object>,
579 pub sub_component: Option<comment_key::SubComponent>,
580}
581
582pub mod comment_key {
583 use super::*;
584
585 #[derive(
586 Clone,
587 Copy,
588 Debug,
589 PartialEq,
590 Eq,
591 PartialOrd,
592 Ord,
593 Serialize,
594 Deserialize,
595 Arbitrary
596 )]
597 pub enum Object {
598 Table(CatalogItemId),
599 View(CatalogItemId),
600 MaterializedView(CatalogItemId),
601 Source(CatalogItemId),
602 Sink(CatalogItemId),
603 Index(CatalogItemId),
604 Func(CatalogItemId),
605 Connection(CatalogItemId),
606 Type(CatalogItemId),
607 Secret(CatalogItemId),
608 ContinualTask(CatalogItemId),
609 Role(RoleId),
610 Database(DatabaseId),
611 Schema(ResolvedSchema),
612 Cluster(ClusterId),
613 ClusterReplica(ClusterReplicaId),
614 NetworkPolicy(NetworkPolicyId),
615 }
616
617 #[derive(
618 Clone,
619 Copy,
620 Debug,
621 PartialEq,
622 Eq,
623 PartialOrd,
624 Ord,
625 Serialize,
626 Deserialize,
627 Arbitrary
628 )]
629 pub enum SubComponent {
630 ColumnPos(u64),
631 }
632}
633
634#[derive(
635 Clone,
636 Debug,
637 Default,
638 PartialEq,
639 Eq,
640 PartialOrd,
641 Ord,
642 Serialize,
643 Deserialize,
644 Arbitrary
645)]
646pub struct CommentValue {
647 pub comment: String,
648}
649
650#[derive(
651 Clone,
652 Copy,
653 Debug,
654 Default,
655 PartialEq,
656 Eq,
657 PartialOrd,
658 Ord,
659 Serialize,
660 Deserialize,
661 Arbitrary
662)]
663pub struct SourceReferencesKey {
664 pub source: Option<CatalogItemId>,
665}
666
667#[derive(
668 Clone,
669 Debug,
670 Default,
671 PartialEq,
672 Eq,
673 PartialOrd,
674 Ord,
675 Serialize,
676 Deserialize,
677 Arbitrary
678)]
679pub struct SourceReferencesValue {
680 pub references: Vec<SourceReference>,
681 #[proptest(filter = "Option::is_some")]
682 pub updated_at: Option<EpochMillis>,
683}
684
685#[derive(
686 Clone,
687 Debug,
688 Default,
689 PartialEq,
690 Eq,
691 PartialOrd,
692 Ord,
693 Serialize,
694 Deserialize,
695 Arbitrary
696)]
697pub struct SourceReference {
698 pub name: String,
699 pub namespace: Option<String>,
700 pub columns: Vec<String>,
701}
702
703#[derive(
704 Clone,
705 Copy,
706 Debug,
707 Default,
708 PartialEq,
709 Eq,
710 PartialOrd,
711 Ord,
712 Serialize,
713 Deserialize,
714 Arbitrary
715)]
716pub struct StorageCollectionMetadataKey {
717 pub id: Option<GlobalId>,
718}
719
720#[derive(
721 Clone,
722 Debug,
723 Default,
724 PartialEq,
725 Eq,
726 PartialOrd,
727 Ord,
728 Serialize,
729 Deserialize,
730 Arbitrary
731)]
732pub struct StorageCollectionMetadataValue {
733 pub shard: String,
734}
735
736#[derive(
737 Clone,
738 Debug,
739 Default,
740 PartialEq,
741 Eq,
742 PartialOrd,
743 Ord,
744 Serialize,
745 Deserialize,
746 Arbitrary
747)]
748pub struct UnfinalizedShardKey {
749 pub shard: String,
750}
751
752#[derive(
753 Clone,
754 Debug,
755 Default,
756 PartialEq,
757 Eq,
758 PartialOrd,
759 Ord,
760 Serialize,
761 Deserialize,
762 Arbitrary
763)]
764pub struct TxnWalShardValue {
765 pub shard: String,
766}
767
768#[derive(
769 Clone,
770 Copy,
771 Debug,
772 Default,
773 PartialEq,
774 Eq,
775 PartialOrd,
776 Ord,
777 Serialize,
778 Deserialize,
779 Arbitrary
780)]
781pub struct Empty {}
782
783#[derive(
784 Clone,
785 Debug,
786 Default,
787 PartialEq,
788 Eq,
789 PartialOrd,
790 Ord,
791 Serialize,
792 Deserialize,
793 Arbitrary
794)]
795pub struct StringWrapper {
796 pub inner: String,
797}
798
799#[derive(
800 Clone,
801 Copy,
802 Debug,
803 Default,
804 PartialEq,
805 Eq,
806 PartialOrd,
807 Ord,
808 Serialize,
809 Deserialize,
810 Arbitrary
811)]
812pub struct Duration {
813 pub secs: u64,
814 pub nanos: u32,
815}
816
817#[derive(
818 Clone,
819 Copy,
820 Debug,
821 Default,
822 PartialEq,
823 Eq,
824 PartialOrd,
825 Ord,
826 Serialize,
827 Deserialize,
828 Arbitrary
829)]
830pub struct EpochMillis {
831 pub millis: u64,
832}
833
834#[derive(
835 Clone,
836 Copy,
837 Debug,
838 Default,
839 PartialEq,
840 Eq,
841 PartialOrd,
842 Ord,
843 Serialize,
844 Deserialize,
845 Arbitrary
846)]
847pub struct Timestamp {
848 pub internal: u64,
849}
850
851#[derive(
852 Clone,
853 Copy,
854 Debug,
855 Default,
856 PartialEq,
857 Eq,
858 PartialOrd,
859 Ord,
860 Serialize,
861 Deserialize,
862 Arbitrary
863)]
864pub struct Version {
865 pub value: u64,
866}
867
868#[derive(
869 Clone,
870 Debug,
871 Default,
872 PartialEq,
873 Eq,
874 PartialOrd,
875 Ord,
876 Serialize,
877 Deserialize,
878 Arbitrary
879)]
880pub struct CatalogItem {
881 pub value: Option<catalog_item::Value>,
882}
883
884pub mod catalog_item {
885 use super::*;
886
887 #[derive(
888 Clone,
889 Debug,
890 Default,
891 PartialEq,
892 Eq,
893 PartialOrd,
894 Ord,
895 Serialize,
896 Deserialize,
897 Arbitrary
898 )]
899 pub struct V1 {
900 pub create_sql: String,
901 }
902
903 #[derive(
904 Clone,
905 Debug,
906 PartialEq,
907 Eq,
908 PartialOrd,
909 Ord,
910 Serialize,
911 Deserialize,
912 Arbitrary
913 )]
914 pub enum Value {
915 V1(V1),
916 }
917}
918
919#[derive(
920 Clone,
921 Copy,
922 Debug,
923 Default,
924 PartialEq,
925 Eq,
926 PartialOrd,
927 Ord,
928 Serialize,
929 Deserialize,
930 Arbitrary
931)]
932pub struct CatalogItemId {
933 pub value: Option<catalog_item_id::Value>,
934}
935
936pub mod catalog_item_id {
937 use super::*;
938
939 #[derive(
940 Clone,
941 Copy,
942 Debug,
943 PartialEq,
944 Eq,
945 PartialOrd,
946 Ord,
947 Serialize,
948 Deserialize,
949 Arbitrary
950 )]
951 pub enum Value {
952 System(u64),
953 User(u64),
954 Transient(u64),
955 IntrospectionSourceIndex(u64),
956 }
957}
958
959#[derive(
960 Clone,
961 Copy,
962 Debug,
963 Default,
964 PartialEq,
965 Eq,
966 PartialOrd,
967 Ord,
968 Serialize,
969 Deserialize,
970 Arbitrary
971)]
972pub struct SystemCatalogItemId {
973 pub value: u64,
974}
975
976#[derive(
977 Clone,
978 Copy,
979 Debug,
980 Default,
981 PartialEq,
982 Eq,
983 PartialOrd,
984 Ord,
985 Serialize,
986 Deserialize,
987 Arbitrary
988)]
989pub struct IntrospectionSourceIndexCatalogItemId {
990 pub value: u64,
991}
992
993#[derive(
994 Clone,
995 Copy,
996 Debug,
997 Default,
998 PartialEq,
999 Eq,
1000 PartialOrd,
1001 Ord,
1002 Serialize,
1003 Deserialize,
1004 Arbitrary
1005)]
1006pub struct GlobalId {
1007 pub value: Option<global_id::Value>,
1008}
1009
1010pub mod global_id {
1011 use super::*;
1012
1013 #[derive(
1014 Clone,
1015 Copy,
1016 Debug,
1017 PartialEq,
1018 Eq,
1019 PartialOrd,
1020 Ord,
1021 Serialize,
1022 Deserialize,
1023 Arbitrary
1024 )]
1025 pub enum Value {
1026 System(u64),
1027 User(u64),
1028 Transient(u64),
1029 Explain(Empty),
1030 IntrospectionSourceIndex(u64),
1031 }
1032}
1033
1034#[derive(
1035 Clone,
1036 Copy,
1037 Debug,
1038 Default,
1039 PartialEq,
1040 Eq,
1041 PartialOrd,
1042 Ord,
1043 Serialize,
1044 Deserialize,
1045 Arbitrary
1046)]
1047pub struct SystemGlobalId {
1048 pub value: u64,
1049}
1050
1051#[derive(
1052 Clone,
1053 Copy,
1054 Debug,
1055 Default,
1056 PartialEq,
1057 Eq,
1058 PartialOrd,
1059 Ord,
1060 Serialize,
1061 Deserialize,
1062 Arbitrary
1063)]
1064pub struct IntrospectionSourceIndexGlobalId {
1065 pub value: u64,
1066}
1067
1068#[derive(
1069 Clone,
1070 Copy,
1071 Debug,
1072 Default,
1073 PartialEq,
1074 Eq,
1075 PartialOrd,
1076 Ord,
1077 Serialize,
1078 Deserialize,
1079 Arbitrary
1080)]
1081pub struct ClusterId {
1082 pub value: Option<cluster_id::Value>,
1083}
1084
1085pub mod cluster_id {
1086 use super::*;
1087
1088 #[derive(
1089 Clone,
1090 Copy,
1091 Debug,
1092 PartialEq,
1093 Eq,
1094 PartialOrd,
1095 Ord,
1096 Serialize,
1097 Deserialize,
1098 Arbitrary
1099 )]
1100 pub enum Value {
1101 System(u64),
1102 User(u64),
1103 }
1104}
1105
1106#[derive(
1107 Clone,
1108 Copy,
1109 Debug,
1110 Default,
1111 PartialEq,
1112 Eq,
1113 PartialOrd,
1114 Ord,
1115 Serialize,
1116 Deserialize,
1117 Arbitrary
1118)]
1119pub struct DatabaseId {
1120 pub value: Option<database_id::Value>,
1121}
1122
1123pub mod database_id {
1124 use super::*;
1125
1126 #[derive(
1127 Clone,
1128 Copy,
1129 Debug,
1130 PartialEq,
1131 Eq,
1132 PartialOrd,
1133 Ord,
1134 Serialize,
1135 Deserialize,
1136 Arbitrary
1137 )]
1138 pub enum Value {
1139 System(u64),
1140 User(u64),
1141 }
1142}
1143
1144#[derive(
1145 Clone,
1146 Copy,
1147 Debug,
1148 Default,
1149 PartialEq,
1150 Eq,
1151 PartialOrd,
1152 Ord,
1153 Serialize,
1154 Deserialize,
1155 Arbitrary
1156)]
1157pub struct ResolvedDatabaseSpecifier {
1158 pub spec: Option<resolved_database_specifier::Spec>,
1159}
1160
1161pub mod resolved_database_specifier {
1162 use super::*;
1163
1164 #[derive(
1165 Clone,
1166 Copy,
1167 Debug,
1168 PartialEq,
1169 Eq,
1170 PartialOrd,
1171 Ord,
1172 Serialize,
1173 Deserialize,
1174 Arbitrary
1175 )]
1176 pub enum Spec {
1177 Ambient(Empty),
1178 Id(DatabaseId),
1179 }
1180}
1181
1182#[derive(
1183 Clone,
1184 Copy,
1185 Debug,
1186 Default,
1187 PartialEq,
1188 Eq,
1189 PartialOrd,
1190 Ord,
1191 Serialize,
1192 Deserialize,
1193 Arbitrary
1194)]
1195pub struct SchemaId {
1196 pub value: Option<schema_id::Value>,
1197}
1198
1199pub mod schema_id {
1200 use super::*;
1201
1202 #[derive(
1203 Clone,
1204 Copy,
1205 Debug,
1206 PartialEq,
1207 Eq,
1208 PartialOrd,
1209 Ord,
1210 Serialize,
1211 Deserialize,
1212 Arbitrary
1213 )]
1214 pub enum Value {
1215 System(u64),
1216 User(u64),
1217 }
1218}
1219
1220#[derive(
1221 Clone,
1222 Copy,
1223 Debug,
1224 Default,
1225 PartialEq,
1226 Eq,
1227 PartialOrd,
1228 Ord,
1229 Serialize,
1230 Deserialize,
1231 Arbitrary
1232)]
1233pub struct SchemaSpecifier {
1234 pub spec: Option<schema_specifier::Spec>,
1235}
1236
1237pub mod schema_specifier {
1238 use super::*;
1239
1240 #[derive(
1241 Clone,
1242 Copy,
1243 Debug,
1244 PartialEq,
1245 Eq,
1246 PartialOrd,
1247 Ord,
1248 Serialize,
1249 Deserialize,
1250 Arbitrary
1251 )]
1252 pub enum Spec {
1253 Temporary(Empty),
1254 Id(SchemaId),
1255 }
1256}
1257
1258#[derive(
1259 Clone,
1260 Copy,
1261 Debug,
1262 Default,
1263 PartialEq,
1264 Eq,
1265 PartialOrd,
1266 Ord,
1267 Serialize,
1268 Deserialize,
1269 Arbitrary
1270)]
1271pub struct ResolvedSchema {
1272 pub database: Option<ResolvedDatabaseSpecifier>,
1273 pub schema: Option<SchemaSpecifier>,
1274}
1275
1276#[derive(
1277 Clone,
1278 Copy,
1279 Debug,
1280 Default,
1281 PartialEq,
1282 Eq,
1283 PartialOrd,
1284 Ord,
1285 Serialize,
1286 Deserialize,
1287 Arbitrary
1288)]
1289pub struct ReplicaId {
1290 pub value: Option<replica_id::Value>,
1291}
1292
1293pub mod replica_id {
1294 use super::*;
1295
1296 #[derive(
1297 Clone,
1298 Copy,
1299 Debug,
1300 PartialEq,
1301 Eq,
1302 PartialOrd,
1303 Ord,
1304 Serialize,
1305 Deserialize,
1306 Arbitrary
1307 )]
1308 pub enum Value {
1309 System(u64),
1310 User(u64),
1311 }
1312}
1313
1314#[derive(
1315 Clone,
1316 Copy,
1317 Debug,
1318 Default,
1319 PartialEq,
1320 Eq,
1321 PartialOrd,
1322 Ord,
1323 Serialize,
1324 Deserialize,
1325 Arbitrary
1326)]
1327pub struct ClusterReplicaId {
1328 pub cluster_id: Option<ClusterId>,
1329 pub replica_id: Option<ReplicaId>,
1330}
1331
1332#[derive(
1333 Clone,
1334 Copy,
1335 Debug,
1336 Default,
1337 PartialEq,
1338 Eq,
1339 PartialOrd,
1340 Ord,
1341 Serialize,
1342 Deserialize,
1343 Arbitrary
1344)]
1345pub struct NetworkPolicyId {
1346 pub value: Option<network_policy_id::Value>,
1347}
1348
1349pub mod network_policy_id {
1350 use super::*;
1351
1352 #[derive(
1353 Clone,
1354 Copy,
1355 Debug,
1356 PartialEq,
1357 Eq,
1358 PartialOrd,
1359 Ord,
1360 Serialize,
1361 Deserialize,
1362 Arbitrary
1363 )]
1364 pub enum Value {
1365 System(u64),
1366 User(u64),
1367 }
1368}
1369
1370#[derive(
1371 Clone,
1372 Copy,
1373 Debug,
1374 Default,
1375 PartialEq,
1376 Eq,
1377 PartialOrd,
1378 Ord,
1379 Serialize,
1380 Deserialize,
1381 Arbitrary
1382)]
1383pub struct ReplicaLogging {
1384 pub log_logging: bool,
1385 pub interval: Option<Duration>,
1386}
1387
1388#[derive(
1389 Clone,
1390 Debug,
1391 Default,
1392 PartialEq,
1393 Eq,
1394 PartialOrd,
1395 Ord,
1396 Serialize,
1397 Deserialize,
1398 Arbitrary
1399)]
1400pub struct OptimizerFeatureOverride {
1401 pub name: String,
1402 pub value: String,
1403}
1404
1405#[derive(
1406 Clone,
1407 Copy,
1408 Debug,
1409 Default,
1410 PartialEq,
1411 Eq,
1412 PartialOrd,
1413 Ord,
1414 Serialize,
1415 Deserialize,
1416 Arbitrary
1417)]
1418pub struct ClusterScheduleRefreshOptions {
1419 #[proptest(filter = "Option::is_some")]
1420 pub rehydration_time_estimate: Option<Duration>,
1421}
1422
1423#[derive(
1424 Clone,
1425 Copy,
1426 Debug,
1427 Default,
1428 PartialEq,
1429 Eq,
1430 PartialOrd,
1431 Ord,
1432 Serialize,
1433 Deserialize,
1434 Arbitrary
1435)]
1436pub struct ClusterSchedule {
1437 pub value: Option<cluster_schedule::Value>,
1438}
1439
1440pub mod cluster_schedule {
1441 use super::*;
1442
1443 #[derive(
1444 Clone,
1445 Copy,
1446 Debug,
1447 PartialEq,
1448 Eq,
1449 PartialOrd,
1450 Ord,
1451 Serialize,
1452 Deserialize,
1453 Arbitrary
1454 )]
1455 pub enum Value {
1456 Manual(Empty),
1457 Refresh(ClusterScheduleRefreshOptions),
1458 }
1459}
1460
1461#[derive(
1462 Clone,
1463 Debug,
1464 Default,
1465 PartialEq,
1466 Eq,
1467 PartialOrd,
1468 Ord,
1469 Serialize,
1470 Deserialize,
1471 Arbitrary
1472)]
1473pub struct ClusterConfig {
1474 pub workload_class: Option<String>,
1475 pub variant: Option<cluster_config::Variant>,
1476}
1477
1478pub mod cluster_config {
1479 use super::*;
1480
1481 #[derive(
1482 Clone,
1483 Debug,
1484 Default,
1485 PartialEq,
1486 Eq,
1487 PartialOrd,
1488 Ord,
1489 Serialize,
1490 Deserialize,
1491 Arbitrary
1492 )]
1493 pub struct ManagedCluster {
1494 pub size: String,
1495 pub replication_factor: u32,
1496 pub availability_zones: Vec<String>,
1497 pub logging: Option<ReplicaLogging>,
1498 pub optimizer_feature_overrides: Vec<OptimizerFeatureOverride>,
1499 pub schedule: Option<ClusterSchedule>,
1500 }
1501
1502 #[derive(
1503 Clone,
1504 Debug,
1505 PartialEq,
1506 Eq,
1507 PartialOrd,
1508 Ord,
1509 Serialize,
1510 Deserialize,
1511 Arbitrary
1512 )]
1513 pub enum Variant {
1514 Unmanaged(Empty),
1515 Managed(ManagedCluster),
1516 }
1517}
1518
1519#[derive(
1520 Clone,
1521 Debug,
1522 Default,
1523 PartialEq,
1524 Eq,
1525 PartialOrd,
1526 Ord,
1527 Serialize,
1528 Deserialize,
1529 Arbitrary
1530)]
1531pub struct ReplicaConfig {
1532 #[proptest(filter = "Option::is_some")]
1533 pub logging: Option<ReplicaLogging>,
1534 #[proptest(filter = "Option::is_some")]
1535 pub location: Option<replica_config::Location>,
1536}
1537
1538pub mod replica_config {
1539 use super::*;
1540
1541 #[derive(
1542 Clone,
1543 Debug,
1544 Default,
1545 PartialEq,
1546 Eq,
1547 PartialOrd,
1548 Ord,
1549 Serialize,
1550 Deserialize,
1551 Arbitrary
1552 )]
1553 pub struct UnmanagedLocation {
1554 pub storagectl_addrs: Vec<String>,
1555 pub computectl_addrs: Vec<String>,
1556 }
1557
1558 #[derive(
1559 Clone,
1560 Debug,
1561 Default,
1562 PartialEq,
1563 Eq,
1564 PartialOrd,
1565 Ord,
1566 Serialize,
1567 Deserialize,
1568 Arbitrary
1569 )]
1570 pub struct ManagedLocation {
1571 pub size: String,
1572 pub availability_zone: Option<String>,
1573 pub internal: bool,
1574 pub billed_as: Option<String>,
1575 pub pending: bool,
1576 }
1577
1578 #[derive(
1579 Clone,
1580 Debug,
1581 PartialEq,
1582 Eq,
1583 PartialOrd,
1584 Ord,
1585 Serialize,
1586 Deserialize,
1587 Arbitrary
1588 )]
1589 pub enum Location {
1590 Unmanaged(UnmanagedLocation),
1591 Managed(ManagedLocation),
1592 }
1593}
1594
1595#[derive(
1596 Clone,
1597 Copy,
1598 Debug,
1599 Default,
1600 PartialEq,
1601 Eq,
1602 PartialOrd,
1603 Ord,
1604 Serialize,
1605 Deserialize,
1606 Arbitrary
1607)]
1608pub struct RoleId {
1609 pub value: Option<role_id::Value>,
1610}
1611
1612pub mod role_id {
1613 use super::*;
1614
1615 #[derive(
1616 Clone,
1617 Copy,
1618 Debug,
1619 PartialEq,
1620 Eq,
1621 PartialOrd,
1622 Ord,
1623 Serialize,
1624 Deserialize,
1625 Arbitrary
1626 )]
1627 pub enum Value {
1628 System(u64),
1629 User(u64),
1630 Public(Empty),
1631 Predefined(u64),
1632 }
1633}
1634
1635#[derive(
1636 Clone,
1637 Copy,
1638 Debug,
1639 Default,
1640 PartialEq,
1641 Eq,
1642 PartialOrd,
1643 Ord,
1644 Serialize,
1645 Deserialize,
1646 Arbitrary
1647)]
1648pub struct RoleAttributes {
1649 pub inherit: bool,
1650 pub superuser: Option<bool>,
1651 pub login: Option<bool>,
1652}
1653
1654#[derive(
1655 Clone,
1656 Debug,
1657 Default,
1658 PartialEq,
1659 Eq,
1660 PartialOrd,
1661 Ord,
1662 Serialize,
1663 Deserialize,
1664 Arbitrary
1665)]
1666pub struct RoleMembership {
1667 pub map: Vec<role_membership::Entry>,
1668}
1669
1670pub mod role_membership {
1671 use super::*;
1672
1673 #[derive(
1674 Clone,
1675 Copy,
1676 Debug,
1677 Default,
1678 PartialEq,
1679 Eq,
1680 PartialOrd,
1681 Ord,
1682 Serialize,
1683 Deserialize,
1684 Arbitrary
1685 )]
1686 pub struct Entry {
1687 pub key: Option<RoleId>,
1688 pub value: Option<RoleId>,
1689 }
1690}
1691
1692#[derive(
1693 Clone,
1694 Debug,
1695 Default,
1696 PartialEq,
1697 Eq,
1698 PartialOrd,
1699 Ord,
1700 Serialize,
1701 Deserialize,
1702 Arbitrary
1703)]
1704pub struct RoleVars {
1705 pub entries: Vec<role_vars::Entry>,
1706}
1707
1708pub mod role_vars {
1709 use super::*;
1710
1711 #[derive(
1712 Clone,
1713 Debug,
1714 Default,
1715 PartialEq,
1716 Eq,
1717 PartialOrd,
1718 Ord,
1719 Serialize,
1720 Deserialize,
1721 Arbitrary
1722 )]
1723 pub struct SqlSet {
1724 pub entries: Vec<String>,
1725 }
1726
1727 #[derive(
1728 Clone,
1729 Debug,
1730 Default,
1731 PartialEq,
1732 Eq,
1733 PartialOrd,
1734 Ord,
1735 Serialize,
1736 Deserialize,
1737 Arbitrary
1738 )]
1739 pub struct Entry {
1740 pub key: String,
1741 pub val: Option<entry::Val>,
1742 }
1743
1744 pub mod entry {
1745 use super::*;
1746
1747 #[derive(
1748 Clone,
1749 Debug,
1750 PartialEq,
1751 Eq,
1752 PartialOrd,
1753 Ord,
1754 Serialize,
1755 Deserialize,
1756 Arbitrary
1757 )]
1758 pub enum Val {
1759 Flat(String),
1760 SqlSet(SqlSet),
1761 }
1762 }
1763}
1764
1765#[derive(
1766 Clone,
1767 Debug,
1768 Default,
1769 PartialEq,
1770 Eq,
1771 PartialOrd,
1772 Ord,
1773 Serialize,
1774 Deserialize,
1775 Arbitrary
1776)]
1777pub struct NetworkPolicyRule {
1778 pub name: String,
1779 pub address: String,
1780 pub action: Option<network_policy_rule::Action>,
1781 pub direction: Option<network_policy_rule::Direction>,
1782}
1783
1784pub mod network_policy_rule {
1785 use super::*;
1786
1787 #[derive(
1788 Clone,
1789 Copy,
1790 Debug,
1791 PartialEq,
1792 Eq,
1793 PartialOrd,
1794 Ord,
1795 Serialize,
1796 Deserialize,
1797 Arbitrary
1798 )]
1799 pub enum Action {
1800 Allow(Empty),
1801 }
1802
1803 #[derive(
1804 Clone,
1805 Copy,
1806 Debug,
1807 PartialEq,
1808 Eq,
1809 PartialOrd,
1810 Ord,
1811 Serialize,
1812 Deserialize,
1813 Arbitrary
1814 )]
1815 pub enum Direction {
1816 Ingress(Empty),
1817 }
1818}
1819
1820#[derive(
1821 Clone,
1822 Copy,
1823 Debug,
1824 Default,
1825 PartialEq,
1826 Eq,
1827 PartialOrd,
1828 Ord,
1829 Serialize,
1830 Deserialize,
1831 Arbitrary
1832)]
1833pub struct AclMode {
1834 pub bitflags: u64,
1835}
1836
1837#[derive(
1838 Clone,
1839 Copy,
1840 Debug,
1841 Default,
1842 PartialEq,
1843 Eq,
1844 PartialOrd,
1845 Ord,
1846 Serialize,
1847 Deserialize,
1848 Arbitrary
1849)]
1850pub struct MzAclItem {
1851 pub grantee: Option<RoleId>,
1852 pub grantor: Option<RoleId>,
1853 pub acl_mode: Option<AclMode>,
1854}
1855
1856#[derive(
1857 Clone,
1858 Copy,
1859 Debug,
1860 Default,
1861 PartialEq,
1862 Eq,
1863 PartialOrd,
1864 Ord,
1865 Serialize,
1866 Deserialize,
1867 Arbitrary
1868)]
1869pub struct DefaultPrivilegesKey {
1870 pub role_id: Option<RoleId>,
1871 pub database_id: Option<DatabaseId>,
1872 pub schema_id: Option<SchemaId>,
1873 pub object_type: i32,
1874 pub grantee: Option<RoleId>,
1875}
1876
1877#[derive(
1878 Clone,
1879 Copy,
1880 Debug,
1881 Default,
1882 PartialEq,
1883 Eq,
1884 PartialOrd,
1885 Ord,
1886 Serialize,
1887 Deserialize,
1888 Arbitrary
1889)]
1890pub struct DefaultPrivilegesValue {
1891 #[proptest(filter = "Option::is_some")]
1892 pub privileges: Option<AclMode>,
1893}
1894
1895#[derive(
1896 Clone,
1897 Copy,
1898 Debug,
1899 Default,
1900 PartialEq,
1901 Eq,
1902 PartialOrd,
1903 Ord,
1904 Serialize,
1905 Deserialize,
1906 Arbitrary
1907)]
1908pub struct SystemPrivilegesKey {
1909 pub grantee: Option<RoleId>,
1910 pub grantor: Option<RoleId>,
1911}
1912
1913#[derive(
1914 Clone,
1915 Copy,
1916 Debug,
1917 Default,
1918 PartialEq,
1919 Eq,
1920 PartialOrd,
1921 Ord,
1922 Serialize,
1923 Deserialize,
1924 Arbitrary
1925)]
1926pub struct SystemPrivilegesValue {
1927 #[proptest(filter = "Option::is_some")]
1928 pub acl_mode: Option<AclMode>,
1929}
1930
1931#[derive(
1932 Clone,
1933 Debug,
1934 Default,
1935 PartialEq,
1936 Eq,
1937 PartialOrd,
1938 Ord,
1939 Serialize,
1940 Deserialize,
1941 Arbitrary
1942)]
1943pub struct AuditLogEventV1 {
1944 pub id: u64,
1945 #[proptest(strategy = "0..=6")]
1946 pub event_type: i32,
1947 #[proptest(strategy = "0..=18")]
1948 pub object_type: i32,
1949 pub user: Option<StringWrapper>,
1950 #[proptest(filter = "Option::is_some")]
1951 pub occurred_at: Option<EpochMillis>,
1952 #[proptest(filter = "Option::is_some")]
1953 pub details: Option<audit_log_event_v1::Details>,
1954}
1955
1956pub mod audit_log_event_v1 {
1957 use super::*;
1958
1959 #[derive(
1960 Clone,
1961 Debug,
1962 Default,
1963 PartialEq,
1964 Eq,
1965 PartialOrd,
1966 Ord,
1967 Serialize,
1968 Deserialize,
1969 Arbitrary
1970 )]
1971 pub struct IdFullNameV1 {
1972 pub id: String,
1973 #[proptest(filter = "Option::is_some")]
1974 pub name: Option<FullNameV1>,
1975 }
1976
1977 #[derive(
1978 Clone,
1979 Debug,
1980 Default,
1981 PartialEq,
1982 Eq,
1983 PartialOrd,
1984 Ord,
1985 Serialize,
1986 Deserialize,
1987 Arbitrary
1988 )]
1989 pub struct FullNameV1 {
1990 pub database: String,
1991 pub schema: String,
1992 pub item: String,
1993 }
1994
1995 #[derive(
1996 Clone,
1997 Debug,
1998 Default,
1999 PartialEq,
2000 Eq,
2001 PartialOrd,
2002 Ord,
2003 Serialize,
2004 Deserialize,
2005 Arbitrary
2006 )]
2007 pub struct IdNameV1 {
2008 pub id: String,
2009 pub name: String,
2010 }
2011
2012 #[derive(
2013 Clone,
2014 Debug,
2015 Default,
2016 PartialEq,
2017 Eq,
2018 PartialOrd,
2019 Ord,
2020 Serialize,
2021 Deserialize,
2022 Arbitrary
2023 )]
2024 pub struct RenameClusterV1 {
2025 pub id: String,
2026 pub old_name: String,
2027 pub new_name: String,
2028 }
2029
2030 #[derive(
2031 Clone,
2032 Debug,
2033 Default,
2034 PartialEq,
2035 Eq,
2036 PartialOrd,
2037 Ord,
2038 Serialize,
2039 Deserialize,
2040 Arbitrary
2041 )]
2042 pub struct RenameClusterReplicaV1 {
2043 pub cluster_id: String,
2044 pub replica_id: String,
2045 pub old_name: String,
2046 pub new_name: String,
2047 }
2048
2049 #[derive(
2050 Clone,
2051 Debug,
2052 Default,
2053 PartialEq,
2054 Eq,
2055 PartialOrd,
2056 Ord,
2057 Serialize,
2058 Deserialize,
2059 Arbitrary
2060 )]
2061 pub struct RenameItemV1 {
2062 pub id: String,
2063 #[proptest(filter = "Option::is_some")]
2064 pub old_name: Option<FullNameV1>,
2065 #[proptest(filter = "Option::is_some")]
2066 pub new_name: Option<FullNameV1>,
2067 }
2068
2069 #[derive(
2070 Clone,
2071 Debug,
2072 Default,
2073 PartialEq,
2074 Eq,
2075 PartialOrd,
2076 Ord,
2077 Serialize,
2078 Deserialize,
2079 Arbitrary
2080 )]
2081 pub struct CreateClusterReplicaV1 {
2082 pub cluster_id: String,
2083 pub cluster_name: String,
2084 pub replica_id: Option<StringWrapper>,
2085 pub replica_name: String,
2086 pub logical_size: String,
2087 pub disk: bool,
2088 pub billed_as: Option<String>,
2089 pub internal: bool,
2090 }
2091
2092 #[derive(
2093 Clone,
2094 Debug,
2095 Default,
2096 PartialEq,
2097 Eq,
2098 PartialOrd,
2099 Ord,
2100 Serialize,
2101 Deserialize,
2102 Arbitrary
2103 )]
2104 pub struct CreateClusterReplicaV2 {
2105 pub cluster_id: String,
2106 pub cluster_name: String,
2107 pub replica_id: Option<StringWrapper>,
2108 pub replica_name: String,
2109 pub logical_size: String,
2110 pub disk: bool,
2111 pub billed_as: Option<String>,
2112 pub internal: bool,
2113 #[proptest(filter = "Option::is_some")]
2114 pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2115 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV1>,
2116 }
2117
2118 #[derive(
2119 Clone,
2120 Debug,
2121 Default,
2122 PartialEq,
2123 Eq,
2124 PartialOrd,
2125 Ord,
2126 Serialize,
2127 Deserialize,
2128 Arbitrary
2129 )]
2130 pub struct CreateClusterReplicaV3 {
2131 pub cluster_id: String,
2132 pub cluster_name: String,
2133 pub replica_id: Option<StringWrapper>,
2134 pub replica_name: String,
2135 pub logical_size: String,
2136 pub disk: bool,
2137 pub billed_as: Option<String>,
2138 pub internal: bool,
2139 #[proptest(filter = "Option::is_some")]
2140 pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2141 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
2142 }
2143
2144 #[derive(
2145 Clone,
2146 Debug,
2147 Default,
2148 PartialEq,
2149 Eq,
2150 PartialOrd,
2151 Ord,
2152 Serialize,
2153 Deserialize,
2154 Arbitrary
2155 )]
2156 pub struct CreateClusterReplicaV4 {
2157 pub cluster_id: String,
2158 pub cluster_name: String,
2159 pub replica_id: Option<StringWrapper>,
2160 pub replica_name: String,
2161 pub logical_size: String,
2162 pub billed_as: Option<String>,
2163 pub internal: bool,
2164 #[proptest(filter = "Option::is_some")]
2165 pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2166 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
2167 }
2168
2169 #[derive(
2170 Clone,
2171 Debug,
2172 Default,
2173 PartialEq,
2174 Eq,
2175 PartialOrd,
2176 Ord,
2177 Serialize,
2178 Deserialize,
2179 Arbitrary
2180 )]
2181 pub struct DropClusterReplicaV1 {
2182 pub cluster_id: String,
2183 pub cluster_name: String,
2184 pub replica_id: Option<StringWrapper>,
2185 pub replica_name: String,
2186 }
2187
2188 #[derive(
2189 Clone,
2190 Debug,
2191 Default,
2192 PartialEq,
2193 Eq,
2194 PartialOrd,
2195 Ord,
2196 Serialize,
2197 Deserialize,
2198 Arbitrary
2199 )]
2200 pub struct DropClusterReplicaV2 {
2201 pub cluster_id: String,
2202 pub cluster_name: String,
2203 pub replica_id: Option<StringWrapper>,
2204 pub replica_name: String,
2205 #[proptest(filter = "Option::is_some")]
2206 pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2207 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV1>,
2208 }
2209
2210 #[derive(
2211 Clone,
2212 Debug,
2213 Default,
2214 PartialEq,
2215 Eq,
2216 PartialOrd,
2217 Ord,
2218 Serialize,
2219 Deserialize,
2220 Arbitrary
2221 )]
2222 pub struct DropClusterReplicaV3 {
2223 pub cluster_id: String,
2224 pub cluster_name: String,
2225 pub replica_id: Option<StringWrapper>,
2226 pub replica_name: String,
2227 #[proptest(filter = "Option::is_some")]
2228 pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2229 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
2230 }
2231
2232 #[derive(
2233 Clone,
2234 Copy,
2235 Debug,
2236 Default,
2237 PartialEq,
2238 Eq,
2239 PartialOrd,
2240 Ord,
2241 Serialize,
2242 Deserialize,
2243 Arbitrary
2244 )]
2245 pub struct CreateOrDropClusterReplicaReasonV1 {
2246 #[proptest(filter = "Option::is_some")]
2247 pub reason: Option<create_or_drop_cluster_replica_reason_v1::Reason>,
2248 }
2249
2250 pub mod create_or_drop_cluster_replica_reason_v1 {
2251 use super::*;
2252
2253 #[derive(
2254 Clone,
2255 Copy,
2256 Debug,
2257 PartialEq,
2258 Eq,
2259 PartialOrd,
2260 Ord,
2261 Serialize,
2262 Deserialize,
2263 Arbitrary
2264 )]
2265 pub enum Reason {
2266 Manual(Empty),
2267 Schedule(Empty),
2268 System(Empty),
2269 }
2270 }
2271
2272 #[derive(
2273 Clone,
2274 Debug,
2275 Default,
2276 PartialEq,
2277 Eq,
2278 PartialOrd,
2279 Ord,
2280 Serialize,
2281 Deserialize,
2282 Arbitrary
2283 )]
2284 pub struct SchedulingDecisionsWithReasonsV1 {
2285 #[proptest(filter = "Option::is_some")]
2286 pub on_refresh: Option<RefreshDecisionWithReasonV1>,
2287 }
2288
2289 #[derive(
2290 Clone,
2291 Debug,
2292 Default,
2293 PartialEq,
2294 Eq,
2295 PartialOrd,
2296 Ord,
2297 Serialize,
2298 Deserialize,
2299 Arbitrary
2300 )]
2301 pub struct SchedulingDecisionsWithReasonsV2 {
2302 #[proptest(filter = "Option::is_some")]
2303 pub on_refresh: Option<RefreshDecisionWithReasonV2>,
2304 }
2305
2306 #[derive(
2307 Clone,
2308 Debug,
2309 Default,
2310 PartialEq,
2311 Eq,
2312 PartialOrd,
2313 Ord,
2314 Serialize,
2315 Deserialize,
2316 Arbitrary
2317 )]
2318 pub struct RefreshDecisionWithReasonV1 {
2319 pub objects_needing_refresh: Vec<String>,
2320 pub rehydration_time_estimate: String,
2321 #[proptest(filter = "Option::is_some")]
2322 pub decision: Option<refresh_decision_with_reason_v1::Decision>,
2323 }
2324
2325 pub mod refresh_decision_with_reason_v1 {
2326 use super::*;
2327
2328 #[derive(
2329 Clone,
2330 Copy,
2331 Debug,
2332 PartialEq,
2333 Eq,
2334 PartialOrd,
2335 Ord,
2336 Serialize,
2337 Deserialize,
2338 Arbitrary
2339 )]
2340 pub enum Decision {
2341 On(Empty),
2342 Off(Empty),
2343 }
2344 }
2345
2346 #[derive(
2347 Clone,
2348 Debug,
2349 Default,
2350 PartialEq,
2351 Eq,
2352 PartialOrd,
2353 Ord,
2354 Serialize,
2355 Deserialize,
2356 Arbitrary
2357 )]
2358 pub struct RefreshDecisionWithReasonV2 {
2359 pub objects_needing_refresh: Vec<String>,
2360 pub objects_needing_compaction: Vec<String>,
2361 pub rehydration_time_estimate: String,
2362 #[proptest(filter = "Option::is_some")]
2363 pub decision: Option<refresh_decision_with_reason_v2::Decision>,
2364 }
2365
2366 pub mod refresh_decision_with_reason_v2 {
2367 use super::*;
2368
2369 #[derive(
2370 Clone,
2371 Copy,
2372 Debug,
2373 PartialEq,
2374 Eq,
2375 PartialOrd,
2376 Ord,
2377 Serialize,
2378 Deserialize,
2379 Arbitrary
2380 )]
2381 pub enum Decision {
2382 On(Empty),
2383 Off(Empty),
2384 }
2385 }
2386
2387 #[derive(
2388 Clone,
2389 Debug,
2390 Default,
2391 PartialEq,
2392 Eq,
2393 PartialOrd,
2394 Ord,
2395 Serialize,
2396 Deserialize,
2397 Arbitrary
2398 )]
2399 pub struct CreateSourceSinkV1 {
2400 pub id: String,
2401 #[proptest(filter = "Option::is_some")]
2402 pub name: Option<FullNameV1>,
2403 pub size: Option<StringWrapper>,
2404 }
2405
2406 #[derive(
2407 Clone,
2408 Debug,
2409 Default,
2410 PartialEq,
2411 Eq,
2412 PartialOrd,
2413 Ord,
2414 Serialize,
2415 Deserialize,
2416 Arbitrary
2417 )]
2418 pub struct CreateSourceSinkV2 {
2419 pub id: String,
2420 #[proptest(filter = "Option::is_some")]
2421 pub name: Option<FullNameV1>,
2422 pub size: Option<StringWrapper>,
2423 pub external_type: String,
2424 }
2425
2426 #[derive(
2427 Clone,
2428 Debug,
2429 Default,
2430 PartialEq,
2431 Eq,
2432 PartialOrd,
2433 Ord,
2434 Serialize,
2435 Deserialize,
2436 Arbitrary
2437 )]
2438 pub struct CreateSourceSinkV3 {
2439 pub id: String,
2440 #[proptest(filter = "Option::is_some")]
2441 pub name: Option<FullNameV1>,
2442 pub external_type: String,
2443 }
2444
2445 #[derive(
2446 Clone,
2447 Debug,
2448 Default,
2449 PartialEq,
2450 Eq,
2451 PartialOrd,
2452 Ord,
2453 Serialize,
2454 Deserialize,
2455 Arbitrary
2456 )]
2457 pub struct CreateSourceSinkV4 {
2458 pub id: String,
2459 pub cluster_id: Option<StringWrapper>,
2460 #[proptest(filter = "Option::is_some")]
2461 pub name: Option<FullNameV1>,
2462 pub external_type: String,
2463 }
2464
2465 #[derive(
2466 Clone,
2467 Debug,
2468 Default,
2469 PartialEq,
2470 Eq,
2471 PartialOrd,
2472 Ord,
2473 Serialize,
2474 Deserialize,
2475 Arbitrary
2476 )]
2477 pub struct CreateIndexV1 {
2478 pub id: String,
2479 pub cluster_id: String,
2480 #[proptest(filter = "Option::is_some")]
2481 pub name: Option<FullNameV1>,
2482 }
2483
2484 #[derive(
2485 Clone,
2486 Debug,
2487 Default,
2488 PartialEq,
2489 Eq,
2490 PartialOrd,
2491 Ord,
2492 Serialize,
2493 Deserialize,
2494 Arbitrary
2495 )]
2496 pub struct CreateMaterializedViewV1 {
2497 pub id: String,
2498 pub cluster_id: String,
2499 #[proptest(filter = "Option::is_some")]
2500 pub name: Option<FullNameV1>,
2501 }
2502
2503 #[derive(
2504 Clone,
2505 Debug,
2506 Default,
2507 PartialEq,
2508 Eq,
2509 PartialOrd,
2510 Ord,
2511 Serialize,
2512 Deserialize,
2513 Arbitrary
2514 )]
2515 pub struct AlterSourceSinkV1 {
2516 pub id: String,
2517 #[proptest(filter = "Option::is_some")]
2518 pub name: Option<FullNameV1>,
2519 pub old_size: Option<StringWrapper>,
2520 pub new_size: Option<StringWrapper>,
2521 }
2522
2523 #[derive(
2524 Clone,
2525 Debug,
2526 Default,
2527 PartialEq,
2528 Eq,
2529 PartialOrd,
2530 Ord,
2531 Serialize,
2532 Deserialize,
2533 Arbitrary
2534 )]
2535 pub struct AlterSetClusterV1 {
2536 pub id: String,
2537 #[proptest(filter = "Option::is_some")]
2538 pub name: Option<FullNameV1>,
2539 pub old_cluster: Option<StringWrapper>,
2540 pub new_cluster: Option<StringWrapper>,
2541 }
2542
2543 #[derive(
2544 Clone,
2545 Debug,
2546 Default,
2547 PartialEq,
2548 Eq,
2549 PartialOrd,
2550 Ord,
2551 Serialize,
2552 Deserialize,
2553 Arbitrary
2554 )]
2555 pub struct GrantRoleV1 {
2556 pub role_id: String,
2557 pub member_id: String,
2558 pub grantor_id: String,
2559 }
2560
2561 #[derive(
2562 Clone,
2563 Debug,
2564 Default,
2565 PartialEq,
2566 Eq,
2567 PartialOrd,
2568 Ord,
2569 Serialize,
2570 Deserialize,
2571 Arbitrary
2572 )]
2573 pub struct GrantRoleV2 {
2574 pub role_id: String,
2575 pub member_id: String,
2576 pub grantor_id: String,
2577 pub executed_by: String,
2578 }
2579
2580 #[derive(
2581 Clone,
2582 Debug,
2583 Default,
2584 PartialEq,
2585 Eq,
2586 PartialOrd,
2587 Ord,
2588 Serialize,
2589 Deserialize,
2590 Arbitrary
2591 )]
2592 pub struct RevokeRoleV1 {
2593 pub role_id: String,
2594 pub member_id: String,
2595 }
2596
2597 #[derive(
2598 Clone,
2599 Debug,
2600 Default,
2601 PartialEq,
2602 Eq,
2603 PartialOrd,
2604 Ord,
2605 Serialize,
2606 Deserialize,
2607 Arbitrary
2608 )]
2609 pub struct RevokeRoleV2 {
2610 pub role_id: String,
2611 pub member_id: String,
2612 pub grantor_id: String,
2613 pub executed_by: String,
2614 }
2615
2616 #[derive(
2617 Clone,
2618 Debug,
2619 Default,
2620 PartialEq,
2621 Eq,
2622 PartialOrd,
2623 Ord,
2624 Serialize,
2625 Deserialize,
2626 Arbitrary
2627 )]
2628 pub struct UpdatePrivilegeV1 {
2629 pub object_id: String,
2630 pub grantee_id: String,
2631 pub grantor_id: String,
2632 pub privileges: String,
2633 }
2634
2635 #[derive(
2636 Clone,
2637 Debug,
2638 Default,
2639 PartialEq,
2640 Eq,
2641 PartialOrd,
2642 Ord,
2643 Serialize,
2644 Deserialize,
2645 Arbitrary
2646 )]
2647 pub struct AlterDefaultPrivilegeV1 {
2648 pub role_id: String,
2649 pub database_id: Option<StringWrapper>,
2650 pub schema_id: Option<StringWrapper>,
2651 pub grantee_id: String,
2652 pub privileges: String,
2653 }
2654
2655 #[derive(
2656 Clone,
2657 Debug,
2658 Default,
2659 PartialEq,
2660 Eq,
2661 PartialOrd,
2662 Ord,
2663 Serialize,
2664 Deserialize,
2665 Arbitrary
2666 )]
2667 pub struct UpdateOwnerV1 {
2668 pub object_id: String,
2669 pub old_owner_id: String,
2670 pub new_owner_id: String,
2671 }
2672
2673 #[derive(
2674 Clone,
2675 Debug,
2676 Default,
2677 PartialEq,
2678 Eq,
2679 PartialOrd,
2680 Ord,
2681 Serialize,
2682 Deserialize,
2683 Arbitrary
2684 )]
2685 pub struct SchemaV1 {
2686 pub id: String,
2687 pub name: String,
2688 pub database_name: String,
2689 }
2690
2691 #[derive(
2692 Clone,
2693 Debug,
2694 Default,
2695 PartialEq,
2696 Eq,
2697 PartialOrd,
2698 Ord,
2699 Serialize,
2700 Deserialize,
2701 Arbitrary
2702 )]
2703 pub struct SchemaV2 {
2704 pub id: String,
2705 pub name: String,
2706 pub database_name: Option<StringWrapper>,
2707 }
2708
2709 #[derive(
2710 Clone,
2711 Debug,
2712 Default,
2713 PartialEq,
2714 Eq,
2715 PartialOrd,
2716 Ord,
2717 Serialize,
2718 Deserialize,
2719 Arbitrary
2720 )]
2721 pub struct RenameSchemaV1 {
2722 pub id: String,
2723 pub database_name: Option<String>,
2724 pub old_name: String,
2725 pub new_name: String,
2726 }
2727
2728 #[derive(
2729 Clone,
2730 Debug,
2731 Default,
2732 PartialEq,
2733 Eq,
2734 PartialOrd,
2735 Ord,
2736 Serialize,
2737 Deserialize,
2738 Arbitrary
2739 )]
2740 pub struct UpdateItemV1 {
2741 pub id: String,
2742 #[proptest(filter = "Option::is_some")]
2743 pub name: Option<FullNameV1>,
2744 }
2745
2746 #[derive(
2747 Clone,
2748 Debug,
2749 Default,
2750 PartialEq,
2751 Eq,
2752 PartialOrd,
2753 Ord,
2754 Serialize,
2755 Deserialize,
2756 Arbitrary
2757 )]
2758 pub struct AlterRetainHistoryV1 {
2759 pub id: String,
2760 #[proptest(filter = "Option::is_some")]
2761 pub old_history: Option<String>,
2762 #[proptest(filter = "Option::is_some")]
2763 pub new_history: Option<String>,
2764 }
2765
2766 #[derive(
2767 Clone,
2768 Debug,
2769 Default,
2770 PartialEq,
2771 Eq,
2772 PartialOrd,
2773 Ord,
2774 Serialize,
2775 Deserialize,
2776 Arbitrary
2777 )]
2778 pub struct ToNewIdV1 {
2779 pub id: String,
2780 pub new_id: String,
2781 }
2782
2783 #[derive(
2784 Clone,
2785 Debug,
2786 Default,
2787 PartialEq,
2788 Eq,
2789 PartialOrd,
2790 Ord,
2791 Serialize,
2792 Deserialize,
2793 Arbitrary
2794 )]
2795 pub struct FromPreviousIdV1 {
2796 pub id: String,
2797 pub previous_id: String,
2798 }
2799
2800 #[derive(
2801 Clone,
2802 Debug,
2803 Default,
2804 PartialEq,
2805 Eq,
2806 PartialOrd,
2807 Ord,
2808 Serialize,
2809 Deserialize,
2810 Arbitrary
2811 )]
2812 pub struct SetV1 {
2813 pub name: String,
2814 pub value: Option<String>,
2815 }
2816
2817 #[derive(
2818 Clone,
2819 Debug,
2820 Default,
2821 PartialEq,
2822 Eq,
2823 PartialOrd,
2824 Ord,
2825 Serialize,
2826 Deserialize,
2827 Arbitrary
2828 )]
2829 pub struct RotateKeysV1 {
2830 pub id: String,
2831 pub name: String,
2832 }
2833
2834 #[derive(
2835 Clone,
2836 Copy,
2837 Debug,
2838 PartialEq,
2839 Eq,
2840 Hash,
2841 PartialOrd,
2842 Ord,
2843 Arbitrary,
2844 IntoPrimitive,
2845 TryFromPrimitive
2846 )]
2847 #[repr(i32)]
2848 pub enum EventType {
2849 Unknown = 0,
2850 Create = 1,
2851 Drop = 2,
2852 Alter = 3,
2853 Grant = 4,
2854 Revoke = 5,
2855 Comment = 6,
2856 }
2857
2858 #[derive(
2859 Clone,
2860 Copy,
2861 Debug,
2862 PartialEq,
2863 Eq,
2864 Hash,
2865 PartialOrd,
2866 Ord,
2867 Arbitrary,
2868 IntoPrimitive,
2869 TryFromPrimitive
2870 )]
2871 #[repr(i32)]
2872 pub enum ObjectType {
2873 Unknown = 0,
2874 Cluster = 1,
2875 ClusterReplica = 2,
2876 Connection = 3,
2877 Database = 4,
2878 Func = 5,
2879 Index = 6,
2880 MaterializedView = 7,
2881 Role = 8,
2882 Secret = 9,
2883 Schema = 10,
2884 Sink = 11,
2885 Source = 12,
2886 Table = 13,
2887 Type = 14,
2888 View = 15,
2889 System = 16,
2890 ContinualTask = 17,
2891 NetworkPolicy = 18,
2892 }
2893
2894 #[derive(
2895 Clone,
2896 Debug,
2897 PartialEq,
2898 Eq,
2899 PartialOrd,
2900 Ord,
2901 Serialize,
2902 Deserialize,
2903 Arbitrary
2904 )]
2905 pub enum Details {
2906 CreateClusterReplicaV1(CreateClusterReplicaV1),
2907 CreateClusterReplicaV2(CreateClusterReplicaV2),
2908 CreateClusterReplicaV3(CreateClusterReplicaV3),
2909 CreateClusterReplicaV4(CreateClusterReplicaV4),
2910 DropClusterReplicaV1(DropClusterReplicaV1),
2911 DropClusterReplicaV2(DropClusterReplicaV2),
2912 DropClusterReplicaV3(DropClusterReplicaV3),
2913 CreateSourceSinkV1(CreateSourceSinkV1),
2914 CreateSourceSinkV2(CreateSourceSinkV2),
2915 AlterSourceSinkV1(AlterSourceSinkV1),
2916 AlterSetClusterV1(AlterSetClusterV1),
2917 GrantRoleV1(GrantRoleV1),
2918 GrantRoleV2(GrantRoleV2),
2919 RevokeRoleV1(RevokeRoleV1),
2920 RevokeRoleV2(RevokeRoleV2),
2921 UpdatePrivilegeV1(UpdatePrivilegeV1),
2922 AlterDefaultPrivilegeV1(AlterDefaultPrivilegeV1),
2923 UpdateOwnerV1(UpdateOwnerV1),
2924 IdFullNameV1(IdFullNameV1),
2925 RenameClusterV1(RenameClusterV1),
2926 RenameClusterReplicaV1(RenameClusterReplicaV1),
2927 RenameItemV1(RenameItemV1),
2928 IdNameV1(IdNameV1),
2929 SchemaV1(SchemaV1),
2930 SchemaV2(SchemaV2),
2931 RenameSchemaV1(RenameSchemaV1),
2932 UpdateItemV1(UpdateItemV1),
2933 CreateSourceSinkV3(CreateSourceSinkV3),
2934 AlterRetainHistoryV1(AlterRetainHistoryV1),
2935 ToNewIdV1(ToNewIdV1),
2936 FromPreviousIdV1(FromPreviousIdV1),
2937 SetV1(SetV1),
2938 ResetAllV1(Empty),
2939 RotateKeysV1(RotateKeysV1),
2940 CreateSourceSinkV4(CreateSourceSinkV4),
2941 CreateIndexV1(CreateIndexV1),
2942 CreateMaterializedViewV1(CreateMaterializedViewV1),
2943 }
2944}
2945
2946#[derive(
2947 Clone,
2948 Debug,
2949 Default,
2950 PartialEq,
2951 Eq,
2952 PartialOrd,
2953 Ord,
2954 Serialize,
2955 Deserialize,
2956 Arbitrary
2957)]
2958pub struct StateUpdateKind {
2959 pub kind: Option<state_update_kind::Kind>,
2960}
2961
2962pub mod state_update_kind {
2963 use super::*;
2964
2965 #[derive(
2966 Clone,
2967 Debug,
2968 Default,
2969 PartialEq,
2970 Eq,
2971 PartialOrd,
2972 Ord,
2973 Serialize,
2974 Deserialize,
2975 Arbitrary
2976 )]
2977 pub struct AuditLog {
2978 #[proptest(filter = "Option::is_some")]
2979 pub key: Option<AuditLogKey>,
2980 }
2981
2982 #[derive(
2983 Clone,
2984 Debug,
2985 Default,
2986 PartialEq,
2987 Eq,
2988 PartialOrd,
2989 Ord,
2990 Serialize,
2991 Deserialize,
2992 Arbitrary
2993 )]
2994 pub struct Cluster {
2995 pub key: Option<ClusterKey>,
2996 pub value: Option<ClusterValue>,
2997 }
2998
2999 #[derive(
3000 Clone,
3001 Debug,
3002 Default,
3003 PartialEq,
3004 Eq,
3005 PartialOrd,
3006 Ord,
3007 Serialize,
3008 Deserialize,
3009 Arbitrary
3010 )]
3011 pub struct ClusterReplica {
3012 pub key: Option<ClusterReplicaKey>,
3013 pub value: Option<ClusterReplicaValue>,
3014 }
3015
3016 #[derive(
3017 Clone,
3018 Debug,
3019 Default,
3020 PartialEq,
3021 Eq,
3022 PartialOrd,
3023 Ord,
3024 Serialize,
3025 Deserialize,
3026 Arbitrary
3027 )]
3028 pub struct Comment {
3029 pub key: Option<CommentKey>,
3030 pub value: Option<CommentValue>,
3031 }
3032
3033 #[derive(
3034 Clone,
3035 Debug,
3036 Default,
3037 PartialEq,
3038 Eq,
3039 PartialOrd,
3040 Ord,
3041 Serialize,
3042 Deserialize,
3043 Arbitrary
3044 )]
3045 pub struct Config {
3046 #[proptest(filter = "Option::is_some")]
3047 pub key: Option<ConfigKey>,
3048 #[proptest(filter = "Option::is_some")]
3049 pub value: Option<ConfigValue>,
3050 }
3051
3052 #[derive(
3053 Clone,
3054 Debug,
3055 Default,
3056 PartialEq,
3057 Eq,
3058 PartialOrd,
3059 Ord,
3060 Serialize,
3061 Deserialize,
3062 Arbitrary
3063 )]
3064 pub struct Database {
3065 pub key: Option<DatabaseKey>,
3066 pub value: Option<DatabaseValue>,
3067 }
3068
3069 #[derive(
3070 Clone,
3071 Copy,
3072 Debug,
3073 Default,
3074 PartialEq,
3075 Eq,
3076 PartialOrd,
3077 Ord,
3078 Serialize,
3079 Deserialize,
3080 Arbitrary
3081 )]
3082 pub struct DefaultPrivileges {
3083 pub key: Option<DefaultPrivilegesKey>,
3084 pub value: Option<DefaultPrivilegesValue>,
3085 }
3086
3087 #[derive(
3088 Clone,
3089 Copy,
3090 Debug,
3091 Default,
3092 PartialEq,
3093 Eq,
3094 PartialOrd,
3095 Ord,
3096 Serialize,
3097 Deserialize,
3098 Arbitrary
3099 )]
3100 pub struct FenceToken {
3101 pub deploy_generation: u64,
3102 pub epoch: i64,
3103 }
3104
3105 #[derive(
3106 Clone,
3107 Debug,
3108 Default,
3109 PartialEq,
3110 Eq,
3111 PartialOrd,
3112 Ord,
3113 Serialize,
3114 Deserialize,
3115 Arbitrary
3116 )]
3117 pub struct IdAlloc {
3118 #[proptest(filter = "Option::is_some")]
3119 pub key: Option<IdAllocKey>,
3120 #[proptest(filter = "Option::is_some")]
3121 pub value: Option<IdAllocValue>,
3122 }
3123
3124 #[derive(
3125 Clone,
3126 Debug,
3127 Default,
3128 PartialEq,
3129 Eq,
3130 PartialOrd,
3131 Ord,
3132 Serialize,
3133 Deserialize,
3134 Arbitrary
3135 )]
3136 pub struct ClusterIntrospectionSourceIndex {
3137 pub key: Option<ClusterIntrospectionSourceIndexKey>,
3138 pub value: Option<ClusterIntrospectionSourceIndexValue>,
3139 }
3140
3141 #[derive(
3142 Clone,
3143 Debug,
3144 Default,
3145 PartialEq,
3146 Eq,
3147 PartialOrd,
3148 Ord,
3149 Serialize,
3150 Deserialize,
3151 Arbitrary
3152 )]
3153 pub struct Item {
3154 pub key: Option<ItemKey>,
3155 pub value: Option<ItemValue>,
3156 }
3157
3158 #[derive(
3159 Clone,
3160 Debug,
3161 Default,
3162 PartialEq,
3163 Eq,
3164 PartialOrd,
3165 Ord,
3166 Serialize,
3167 Deserialize,
3168 Arbitrary
3169 )]
3170 pub struct Role {
3171 pub key: Option<RoleKey>,
3172 pub value: Option<RoleValue>,
3173 }
3174
3175 #[derive(
3176 Clone,
3177 Debug,
3178 Default,
3179 PartialEq,
3180 Eq,
3181 PartialOrd,
3182 Ord,
3183 Serialize,
3184 Deserialize,
3185 Arbitrary
3186 )]
3187 pub struct RoleAuth {
3188 pub key: Option<RoleAuthKey>,
3189 pub value: Option<RoleAuthValue>,
3190 }
3191
3192 #[derive(
3193 Clone,
3194 Debug,
3195 Default,
3196 PartialEq,
3197 Eq,
3198 PartialOrd,
3199 Ord,
3200 Serialize,
3201 Deserialize,
3202 Arbitrary
3203 )]
3204 pub struct NetworkPolicy {
3205 pub key: Option<NetworkPolicyKey>,
3206 pub value: Option<NetworkPolicyValue>,
3207 }
3208
3209 #[derive(
3210 Clone,
3211 Debug,
3212 Default,
3213 PartialEq,
3214 Eq,
3215 PartialOrd,
3216 Ord,
3217 Serialize,
3218 Deserialize,
3219 Arbitrary
3220 )]
3221 pub struct Schema {
3222 pub key: Option<SchemaKey>,
3223 pub value: Option<SchemaValue>,
3224 }
3225
3226 #[derive(
3227 Clone,
3228 Debug,
3229 Default,
3230 PartialEq,
3231 Eq,
3232 PartialOrd,
3233 Ord,
3234 Serialize,
3235 Deserialize,
3236 Arbitrary
3237 )]
3238 pub struct Setting {
3239 #[proptest(filter = "Option::is_some")]
3240 pub key: Option<SettingKey>,
3241 #[proptest(filter = "Option::is_some")]
3242 pub value: Option<SettingValue>,
3243 }
3244
3245 #[derive(
3246 Clone,
3247 Debug,
3248 Default,
3249 PartialEq,
3250 Eq,
3251 PartialOrd,
3252 Ord,
3253 Serialize,
3254 Deserialize,
3255 Arbitrary
3256 )]
3257 pub struct ServerConfiguration {
3258 #[proptest(filter = "Option::is_some")]
3259 pub key: Option<ServerConfigurationKey>,
3260 #[proptest(filter = "Option::is_some")]
3261 pub value: Option<ServerConfigurationValue>,
3262 }
3263
3264 #[derive(
3265 Clone,
3266 Debug,
3267 Default,
3268 PartialEq,
3269 Eq,
3270 PartialOrd,
3271 Ord,
3272 Serialize,
3273 Deserialize,
3274 Arbitrary
3275 )]
3276 pub struct SourceReferences {
3277 pub key: Option<SourceReferencesKey>,
3278 pub value: Option<SourceReferencesValue>,
3279 }
3280
3281 #[derive(
3282 Clone,
3283 Debug,
3284 Default,
3285 PartialEq,
3286 Eq,
3287 PartialOrd,
3288 Ord,
3289 Serialize,
3290 Deserialize,
3291 Arbitrary
3292 )]
3293 pub struct GidMapping {
3294 pub key: Option<GidMappingKey>,
3295 pub value: Option<GidMappingValue>,
3296 }
3297
3298 #[derive(
3299 Clone,
3300 Copy,
3301 Debug,
3302 Default,
3303 PartialEq,
3304 Eq,
3305 PartialOrd,
3306 Ord,
3307 Serialize,
3308 Deserialize,
3309 Arbitrary
3310 )]
3311 pub struct SystemPrivileges {
3312 pub key: Option<SystemPrivilegesKey>,
3313 pub value: Option<SystemPrivilegesValue>,
3314 }
3315
3316 #[derive(
3317 Clone,
3318 Debug,
3319 Default,
3320 PartialEq,
3321 Eq,
3322 PartialOrd,
3323 Ord,
3324 Serialize,
3325 Deserialize,
3326 Arbitrary
3327 )]
3328 pub struct StorageCollectionMetadata {
3329 pub key: Option<StorageCollectionMetadataKey>,
3330 pub value: Option<StorageCollectionMetadataValue>,
3331 }
3332
3333 #[derive(
3334 Clone,
3335 Debug,
3336 Default,
3337 PartialEq,
3338 Eq,
3339 PartialOrd,
3340 Ord,
3341 Serialize,
3342 Deserialize,
3343 Arbitrary
3344 )]
3345 pub struct UnfinalizedShard {
3346 #[proptest(filter = "Option::is_some")]
3347 pub key: Option<UnfinalizedShardKey>,
3348 }
3349
3350 #[derive(
3351 Clone,
3352 Debug,
3353 Default,
3354 PartialEq,
3355 Eq,
3356 PartialOrd,
3357 Ord,
3358 Serialize,
3359 Deserialize,
3360 Arbitrary
3361 )]
3362 pub struct TxnWalShard {
3363 #[proptest(filter = "Option::is_some")]
3364 pub value: Option<TxnWalShardValue>,
3365 }
3366
3367 #[derive(
3368 Clone,
3369 Debug,
3370 PartialEq,
3371 Eq,
3372 PartialOrd,
3373 Ord,
3374 Serialize,
3375 Deserialize,
3376 Arbitrary
3377 )]
3378 #[serde(tag = "kind")]
3381 pub enum Kind {
3382 AuditLog(AuditLog),
3383 Cluster(Cluster),
3384 ClusterReplica(ClusterReplica),
3385 Comment(Comment),
3386 Config(Config),
3387 Database(Database),
3388 DefaultPrivileges(DefaultPrivileges),
3389 IdAlloc(IdAlloc),
3390 ClusterIntrospectionSourceIndex(ClusterIntrospectionSourceIndex),
3391 Item(Item),
3392 Role(Role),
3393 Schema(Schema),
3394 Setting(Setting),
3395 ServerConfiguration(ServerConfiguration),
3396 GidMapping(GidMapping),
3397 SystemPrivileges(SystemPrivileges),
3398 StorageCollectionMetadata(StorageCollectionMetadata),
3399 UnfinalizedShard(UnfinalizedShard),
3400 TxnWalShard(TxnWalShard),
3401 SourceReferences(SourceReferences),
3402 FenceToken(FenceToken),
3403 NetworkPolicy(NetworkPolicy),
3404 RoleAuth(RoleAuth),
3405 }
3406}
3407
3408#[derive(
3409 Clone,
3410 Copy,
3411 Debug,
3412 PartialEq,
3413 Eq,
3414 Hash,
3415 PartialOrd,
3416 Ord,
3417 Arbitrary,
3418 IntoPrimitive,
3419 TryFromPrimitive
3420)]
3421#[repr(i32)]
3422pub enum CatalogItemType {
3423 Unknown = 0,
3424 Table = 1,
3425 Source = 2,
3426 Sink = 3,
3427 View = 4,
3428 MaterializedView = 5,
3429 Index = 6,
3430 Type = 7,
3431 Func = 8,
3432 Secret = 9,
3433 Connection = 10,
3434 ContinualTask = 11,
3435}
3436
3437#[derive(
3438 Clone,
3439 Copy,
3440 Debug,
3441 PartialEq,
3442 Eq,
3443 Hash,
3444 PartialOrd,
3445 Ord,
3446 Arbitrary,
3447 IntoPrimitive,
3448 TryFromPrimitive
3449)]
3450#[repr(i32)]
3451pub enum ObjectType {
3452 Unknown = 0,
3453 Table = 1,
3454 View = 2,
3455 MaterializedView = 3,
3456 Source = 4,
3457 Sink = 5,
3458 Index = 6,
3459 Type = 7,
3460 Role = 8,
3461 Cluster = 9,
3462 ClusterReplica = 10,
3463 Secret = 11,
3464 Connection = 12,
3465 Database = 13,
3466 Schema = 14,
3467 Func = 15,
3468 ContinualTask = 16,
3469 NetworkPolicy = 17,
3470}