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