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 storage_addrs: Vec<String>,
1551 pub computectl_addrs: Vec<String>,
1552 pub compute_addrs: Vec<String>,
1553 pub workers: u64,
1554 }
1555
1556 #[derive(
1557 Clone,
1558 Debug,
1559 Default,
1560 PartialEq,
1561 Eq,
1562 PartialOrd,
1563 Ord,
1564 Serialize,
1565 Deserialize,
1566 Arbitrary
1567 )]
1568 pub struct ManagedLocation {
1569 pub size: String,
1570 pub availability_zone: Option<String>,
1571 pub disk: bool,
1572 pub internal: bool,
1573 pub billed_as: Option<String>,
1574 pub pending: bool,
1575 }
1576
1577 #[derive(
1578 Clone,
1579 Debug,
1580 PartialEq,
1581 Eq,
1582 PartialOrd,
1583 Ord,
1584 Serialize,
1585 Deserialize,
1586 Arbitrary
1587 )]
1588 pub enum Location {
1589 Unmanaged(UnmanagedLocation),
1590 Managed(ManagedLocation),
1591 }
1592}
1593
1594#[derive(
1595 Clone,
1596 Copy,
1597 Debug,
1598 Default,
1599 PartialEq,
1600 Eq,
1601 PartialOrd,
1602 Ord,
1603 Serialize,
1604 Deserialize,
1605 Arbitrary
1606)]
1607pub struct RoleId {
1608 pub value: Option<role_id::Value>,
1609}
1610
1611pub mod role_id {
1612 use super::*;
1613
1614 #[derive(
1615 Clone,
1616 Copy,
1617 Debug,
1618 PartialEq,
1619 Eq,
1620 PartialOrd,
1621 Ord,
1622 Serialize,
1623 Deserialize,
1624 Arbitrary
1625 )]
1626 pub enum Value {
1627 System(u64),
1628 User(u64),
1629 Public(Empty),
1630 Predefined(u64),
1631 }
1632}
1633
1634#[derive(
1635 Clone,
1636 Copy,
1637 Debug,
1638 Default,
1639 PartialEq,
1640 Eq,
1641 PartialOrd,
1642 Ord,
1643 Serialize,
1644 Deserialize,
1645 Arbitrary
1646)]
1647pub struct RoleAttributes {
1648 pub inherit: bool,
1649 pub superuser: Option<bool>,
1650 pub login: Option<bool>,
1651}
1652
1653#[derive(
1654 Clone,
1655 Debug,
1656 Default,
1657 PartialEq,
1658 Eq,
1659 PartialOrd,
1660 Ord,
1661 Serialize,
1662 Deserialize,
1663 Arbitrary
1664)]
1665pub struct RoleMembership {
1666 pub map: Vec<role_membership::Entry>,
1667}
1668
1669pub mod role_membership {
1670 use super::*;
1671
1672 #[derive(
1673 Clone,
1674 Copy,
1675 Debug,
1676 Default,
1677 PartialEq,
1678 Eq,
1679 PartialOrd,
1680 Ord,
1681 Serialize,
1682 Deserialize,
1683 Arbitrary
1684 )]
1685 pub struct Entry {
1686 pub key: Option<RoleId>,
1687 pub value: Option<RoleId>,
1688 }
1689}
1690
1691#[derive(
1692 Clone,
1693 Debug,
1694 Default,
1695 PartialEq,
1696 Eq,
1697 PartialOrd,
1698 Ord,
1699 Serialize,
1700 Deserialize,
1701 Arbitrary
1702)]
1703pub struct RoleVars {
1704 pub entries: Vec<role_vars::Entry>,
1705}
1706
1707pub mod role_vars {
1708 use super::*;
1709
1710 #[derive(
1711 Clone,
1712 Debug,
1713 Default,
1714 PartialEq,
1715 Eq,
1716 PartialOrd,
1717 Ord,
1718 Serialize,
1719 Deserialize,
1720 Arbitrary
1721 )]
1722 pub struct SqlSet {
1723 pub entries: Vec<String>,
1724 }
1725
1726 #[derive(
1727 Clone,
1728 Debug,
1729 Default,
1730 PartialEq,
1731 Eq,
1732 PartialOrd,
1733 Ord,
1734 Serialize,
1735 Deserialize,
1736 Arbitrary
1737 )]
1738 pub struct Entry {
1739 pub key: String,
1740 pub val: Option<entry::Val>,
1741 }
1742
1743 pub mod entry {
1744 use super::*;
1745
1746 #[derive(
1747 Clone,
1748 Debug,
1749 PartialEq,
1750 Eq,
1751 PartialOrd,
1752 Ord,
1753 Serialize,
1754 Deserialize,
1755 Arbitrary
1756 )]
1757 pub enum Val {
1758 Flat(String),
1759 SqlSet(SqlSet),
1760 }
1761 }
1762}
1763
1764#[derive(
1765 Clone,
1766 Debug,
1767 Default,
1768 PartialEq,
1769 Eq,
1770 PartialOrd,
1771 Ord,
1772 Serialize,
1773 Deserialize,
1774 Arbitrary
1775)]
1776pub struct NetworkPolicyRule {
1777 pub name: String,
1778 pub address: String,
1779 pub action: Option<network_policy_rule::Action>,
1780 pub direction: Option<network_policy_rule::Direction>,
1781}
1782
1783pub mod network_policy_rule {
1784 use super::*;
1785
1786 #[derive(
1787 Clone,
1788 Copy,
1789 Debug,
1790 PartialEq,
1791 Eq,
1792 PartialOrd,
1793 Ord,
1794 Serialize,
1795 Deserialize,
1796 Arbitrary
1797 )]
1798 pub enum Action {
1799 Allow(Empty),
1800 }
1801
1802 #[derive(
1803 Clone,
1804 Copy,
1805 Debug,
1806 PartialEq,
1807 Eq,
1808 PartialOrd,
1809 Ord,
1810 Serialize,
1811 Deserialize,
1812 Arbitrary
1813 )]
1814 pub enum Direction {
1815 Ingress(Empty),
1816 }
1817}
1818
1819#[derive(
1820 Clone,
1821 Copy,
1822 Debug,
1823 Default,
1824 PartialEq,
1825 Eq,
1826 PartialOrd,
1827 Ord,
1828 Serialize,
1829 Deserialize,
1830 Arbitrary
1831)]
1832pub struct AclMode {
1833 pub bitflags: u64,
1834}
1835
1836#[derive(
1837 Clone,
1838 Copy,
1839 Debug,
1840 Default,
1841 PartialEq,
1842 Eq,
1843 PartialOrd,
1844 Ord,
1845 Serialize,
1846 Deserialize,
1847 Arbitrary
1848)]
1849pub struct MzAclItem {
1850 pub grantee: Option<RoleId>,
1851 pub grantor: Option<RoleId>,
1852 pub acl_mode: Option<AclMode>,
1853}
1854
1855#[derive(
1856 Clone,
1857 Copy,
1858 Debug,
1859 Default,
1860 PartialEq,
1861 Eq,
1862 PartialOrd,
1863 Ord,
1864 Serialize,
1865 Deserialize,
1866 Arbitrary
1867)]
1868pub struct DefaultPrivilegesKey {
1869 pub role_id: Option<RoleId>,
1870 pub database_id: Option<DatabaseId>,
1871 pub schema_id: Option<SchemaId>,
1872 pub object_type: i32,
1873 pub grantee: Option<RoleId>,
1874}
1875
1876#[derive(
1877 Clone,
1878 Copy,
1879 Debug,
1880 Default,
1881 PartialEq,
1882 Eq,
1883 PartialOrd,
1884 Ord,
1885 Serialize,
1886 Deserialize,
1887 Arbitrary
1888)]
1889pub struct DefaultPrivilegesValue {
1890 pub privileges: Option<AclMode>,
1891}
1892
1893#[derive(
1894 Clone,
1895 Copy,
1896 Debug,
1897 Default,
1898 PartialEq,
1899 Eq,
1900 PartialOrd,
1901 Ord,
1902 Serialize,
1903 Deserialize,
1904 Arbitrary
1905)]
1906pub struct SystemPrivilegesKey {
1907 pub grantee: Option<RoleId>,
1908 pub grantor: Option<RoleId>,
1909}
1910
1911#[derive(
1912 Clone,
1913 Copy,
1914 Debug,
1915 Default,
1916 PartialEq,
1917 Eq,
1918 PartialOrd,
1919 Ord,
1920 Serialize,
1921 Deserialize,
1922 Arbitrary
1923)]
1924pub struct SystemPrivilegesValue {
1925 pub acl_mode: Option<AclMode>,
1926}
1927
1928#[derive(
1929 Clone,
1930 Debug,
1931 Default,
1932 PartialEq,
1933 Eq,
1934 PartialOrd,
1935 Ord,
1936 Serialize,
1937 Deserialize,
1938 Arbitrary
1939)]
1940pub struct AuditLogEventV1 {
1941 pub id: u64,
1942 pub event_type: i32,
1943 pub object_type: i32,
1944 pub user: Option<StringWrapper>,
1945 pub occurred_at: Option<EpochMillis>,
1946 pub details: Option<audit_log_event_v1::Details>,
1947}
1948
1949pub mod audit_log_event_v1 {
1950 use super::*;
1951
1952 #[derive(
1953 Clone,
1954 Debug,
1955 Default,
1956 PartialEq,
1957 Eq,
1958 PartialOrd,
1959 Ord,
1960 Serialize,
1961 Deserialize,
1962 Arbitrary
1963 )]
1964 pub struct IdFullNameV1 {
1965 pub id: String,
1966 pub name: Option<FullNameV1>,
1967 }
1968
1969 #[derive(
1970 Clone,
1971 Debug,
1972 Default,
1973 PartialEq,
1974 Eq,
1975 PartialOrd,
1976 Ord,
1977 Serialize,
1978 Deserialize,
1979 Arbitrary
1980 )]
1981 pub struct FullNameV1 {
1982 pub database: String,
1983 pub schema: String,
1984 pub item: String,
1985 }
1986
1987 #[derive(
1988 Clone,
1989 Debug,
1990 Default,
1991 PartialEq,
1992 Eq,
1993 PartialOrd,
1994 Ord,
1995 Serialize,
1996 Deserialize,
1997 Arbitrary
1998 )]
1999 pub struct IdNameV1 {
2000 pub id: String,
2001 pub name: String,
2002 }
2003
2004 #[derive(
2005 Clone,
2006 Debug,
2007 Default,
2008 PartialEq,
2009 Eq,
2010 PartialOrd,
2011 Ord,
2012 Serialize,
2013 Deserialize,
2014 Arbitrary
2015 )]
2016 pub struct RenameClusterV1 {
2017 pub id: String,
2018 pub old_name: String,
2019 pub new_name: String,
2020 }
2021
2022 #[derive(
2023 Clone,
2024 Debug,
2025 Default,
2026 PartialEq,
2027 Eq,
2028 PartialOrd,
2029 Ord,
2030 Serialize,
2031 Deserialize,
2032 Arbitrary
2033 )]
2034 pub struct RenameClusterReplicaV1 {
2035 pub cluster_id: String,
2036 pub replica_id: String,
2037 pub old_name: String,
2038 pub new_name: String,
2039 }
2040
2041 #[derive(
2042 Clone,
2043 Debug,
2044 Default,
2045 PartialEq,
2046 Eq,
2047 PartialOrd,
2048 Ord,
2049 Serialize,
2050 Deserialize,
2051 Arbitrary
2052 )]
2053 pub struct RenameItemV1 {
2054 pub id: String,
2055 pub old_name: Option<FullNameV1>,
2056 pub new_name: Option<FullNameV1>,
2057 }
2058
2059 #[derive(
2060 Clone,
2061 Debug,
2062 Default,
2063 PartialEq,
2064 Eq,
2065 PartialOrd,
2066 Ord,
2067 Serialize,
2068 Deserialize,
2069 Arbitrary
2070 )]
2071 pub struct CreateClusterReplicaV1 {
2072 pub cluster_id: String,
2073 pub cluster_name: String,
2074 pub replica_id: Option<StringWrapper>,
2075 pub replica_name: String,
2076 pub logical_size: String,
2077 pub disk: bool,
2078 pub billed_as: Option<String>,
2079 pub internal: bool,
2080 }
2081
2082 #[derive(
2083 Clone,
2084 Debug,
2085 Default,
2086 PartialEq,
2087 Eq,
2088 PartialOrd,
2089 Ord,
2090 Serialize,
2091 Deserialize,
2092 Arbitrary
2093 )]
2094 pub struct CreateClusterReplicaV2 {
2095 pub cluster_id: String,
2096 pub cluster_name: String,
2097 pub replica_id: Option<StringWrapper>,
2098 pub replica_name: String,
2099 pub logical_size: String,
2100 pub disk: bool,
2101 pub billed_as: Option<String>,
2102 pub internal: bool,
2103 pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2104 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV1>,
2105 }
2106
2107 #[derive(
2108 Clone,
2109 Debug,
2110 Default,
2111 PartialEq,
2112 Eq,
2113 PartialOrd,
2114 Ord,
2115 Serialize,
2116 Deserialize,
2117 Arbitrary
2118 )]
2119 pub struct CreateClusterReplicaV3 {
2120 pub cluster_id: String,
2121 pub cluster_name: String,
2122 pub replica_id: Option<StringWrapper>,
2123 pub replica_name: String,
2124 pub logical_size: String,
2125 pub disk: bool,
2126 pub billed_as: Option<String>,
2127 pub internal: bool,
2128 pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2129 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
2130 }
2131
2132 #[derive(
2133 Clone,
2134 Debug,
2135 Default,
2136 PartialEq,
2137 Eq,
2138 PartialOrd,
2139 Ord,
2140 Serialize,
2141 Deserialize,
2142 Arbitrary
2143 )]
2144 pub struct DropClusterReplicaV1 {
2145 pub cluster_id: String,
2146 pub cluster_name: String,
2147 pub replica_id: Option<StringWrapper>,
2148 pub replica_name: String,
2149 }
2150
2151 #[derive(
2152 Clone,
2153 Debug,
2154 Default,
2155 PartialEq,
2156 Eq,
2157 PartialOrd,
2158 Ord,
2159 Serialize,
2160 Deserialize,
2161 Arbitrary
2162 )]
2163 pub struct DropClusterReplicaV2 {
2164 pub cluster_id: String,
2165 pub cluster_name: String,
2166 pub replica_id: Option<StringWrapper>,
2167 pub replica_name: String,
2168 pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2169 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV1>,
2170 }
2171
2172 #[derive(
2173 Clone,
2174 Debug,
2175 Default,
2176 PartialEq,
2177 Eq,
2178 PartialOrd,
2179 Ord,
2180 Serialize,
2181 Deserialize,
2182 Arbitrary
2183 )]
2184 pub struct DropClusterReplicaV3 {
2185 pub cluster_id: String,
2186 pub cluster_name: String,
2187 pub replica_id: Option<StringWrapper>,
2188 pub replica_name: String,
2189 pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2190 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
2191 }
2192
2193 #[derive(
2194 Clone,
2195 Copy,
2196 Debug,
2197 Default,
2198 PartialEq,
2199 Eq,
2200 PartialOrd,
2201 Ord,
2202 Serialize,
2203 Deserialize,
2204 Arbitrary
2205 )]
2206 pub struct CreateOrDropClusterReplicaReasonV1 {
2207 pub reason: Option<create_or_drop_cluster_replica_reason_v1::Reason>,
2208 }
2209
2210 pub mod create_or_drop_cluster_replica_reason_v1 {
2211 use super::*;
2212
2213 #[derive(
2214 Clone,
2215 Copy,
2216 Debug,
2217 PartialEq,
2218 Eq,
2219 PartialOrd,
2220 Ord,
2221 Serialize,
2222 Deserialize,
2223 Arbitrary
2224 )]
2225 pub enum Reason {
2226 Manual(Empty),
2227 Schedule(Empty),
2228 System(Empty),
2229 }
2230 }
2231
2232 #[derive(
2233 Clone,
2234 Debug,
2235 Default,
2236 PartialEq,
2237 Eq,
2238 PartialOrd,
2239 Ord,
2240 Serialize,
2241 Deserialize,
2242 Arbitrary
2243 )]
2244 pub struct SchedulingDecisionsWithReasonsV1 {
2245 pub on_refresh: Option<RefreshDecisionWithReasonV1>,
2246 }
2247
2248 #[derive(
2249 Clone,
2250 Debug,
2251 Default,
2252 PartialEq,
2253 Eq,
2254 PartialOrd,
2255 Ord,
2256 Serialize,
2257 Deserialize,
2258 Arbitrary
2259 )]
2260 pub struct SchedulingDecisionsWithReasonsV2 {
2261 pub on_refresh: Option<RefreshDecisionWithReasonV2>,
2262 }
2263
2264 #[derive(
2265 Clone,
2266 Debug,
2267 Default,
2268 PartialEq,
2269 Eq,
2270 PartialOrd,
2271 Ord,
2272 Serialize,
2273 Deserialize,
2274 Arbitrary
2275 )]
2276 pub struct RefreshDecisionWithReasonV1 {
2277 pub objects_needing_refresh: Vec<String>,
2278 pub rehydration_time_estimate: String,
2279 pub decision: Option<refresh_decision_with_reason_v1::Decision>,
2280 }
2281
2282 pub mod refresh_decision_with_reason_v1 {
2283 use super::*;
2284
2285 #[derive(
2286 Clone,
2287 Copy,
2288 Debug,
2289 PartialEq,
2290 Eq,
2291 PartialOrd,
2292 Ord,
2293 Serialize,
2294 Deserialize,
2295 Arbitrary
2296 )]
2297 pub enum Decision {
2298 On(Empty),
2299 Off(Empty),
2300 }
2301 }
2302
2303 #[derive(
2304 Clone,
2305 Debug,
2306 Default,
2307 PartialEq,
2308 Eq,
2309 PartialOrd,
2310 Ord,
2311 Serialize,
2312 Deserialize,
2313 Arbitrary
2314 )]
2315 pub struct RefreshDecisionWithReasonV2 {
2316 pub objects_needing_refresh: Vec<String>,
2317 pub objects_needing_compaction: Vec<String>,
2318 pub rehydration_time_estimate: String,
2319 pub decision: Option<refresh_decision_with_reason_v2::Decision>,
2320 }
2321
2322 pub mod refresh_decision_with_reason_v2 {
2323 use super::*;
2324
2325 #[derive(
2326 Clone,
2327 Copy,
2328 Debug,
2329 PartialEq,
2330 Eq,
2331 PartialOrd,
2332 Ord,
2333 Serialize,
2334 Deserialize,
2335 Arbitrary
2336 )]
2337 pub enum Decision {
2338 On(Empty),
2339 Off(Empty),
2340 }
2341 }
2342
2343 #[derive(
2344 Clone,
2345 Debug,
2346 Default,
2347 PartialEq,
2348 Eq,
2349 PartialOrd,
2350 Ord,
2351 Serialize,
2352 Deserialize,
2353 Arbitrary
2354 )]
2355 pub struct CreateSourceSinkV1 {
2356 pub id: String,
2357 pub name: Option<FullNameV1>,
2358 pub size: Option<StringWrapper>,
2359 }
2360
2361 #[derive(
2362 Clone,
2363 Debug,
2364 Default,
2365 PartialEq,
2366 Eq,
2367 PartialOrd,
2368 Ord,
2369 Serialize,
2370 Deserialize,
2371 Arbitrary
2372 )]
2373 pub struct CreateSourceSinkV2 {
2374 pub id: String,
2375 pub name: Option<FullNameV1>,
2376 pub size: Option<StringWrapper>,
2377 pub external_type: String,
2378 }
2379
2380 #[derive(
2381 Clone,
2382 Debug,
2383 Default,
2384 PartialEq,
2385 Eq,
2386 PartialOrd,
2387 Ord,
2388 Serialize,
2389 Deserialize,
2390 Arbitrary
2391 )]
2392 pub struct CreateSourceSinkV3 {
2393 pub id: String,
2394 pub name: Option<FullNameV1>,
2395 pub external_type: String,
2396 }
2397
2398 #[derive(
2399 Clone,
2400 Debug,
2401 Default,
2402 PartialEq,
2403 Eq,
2404 PartialOrd,
2405 Ord,
2406 Serialize,
2407 Deserialize,
2408 Arbitrary
2409 )]
2410 pub struct CreateSourceSinkV4 {
2411 pub id: String,
2412 pub cluster_id: Option<StringWrapper>,
2413 pub name: Option<FullNameV1>,
2414 pub external_type: String,
2415 }
2416
2417 #[derive(
2418 Clone,
2419 Debug,
2420 Default,
2421 PartialEq,
2422 Eq,
2423 PartialOrd,
2424 Ord,
2425 Serialize,
2426 Deserialize,
2427 Arbitrary
2428 )]
2429 pub struct CreateIndexV1 {
2430 pub id: String,
2431 pub cluster_id: String,
2432 pub name: Option<FullNameV1>,
2433 }
2434
2435 #[derive(
2436 Clone,
2437 Debug,
2438 Default,
2439 PartialEq,
2440 Eq,
2441 PartialOrd,
2442 Ord,
2443 Serialize,
2444 Deserialize,
2445 Arbitrary
2446 )]
2447 pub struct CreateMaterializedViewV1 {
2448 pub id: String,
2449 pub cluster_id: String,
2450 pub name: Option<FullNameV1>,
2451 }
2452
2453 #[derive(
2454 Clone,
2455 Debug,
2456 Default,
2457 PartialEq,
2458 Eq,
2459 PartialOrd,
2460 Ord,
2461 Serialize,
2462 Deserialize,
2463 Arbitrary
2464 )]
2465 pub struct AlterSourceSinkV1 {
2466 pub id: String,
2467 pub name: Option<FullNameV1>,
2468 pub old_size: Option<StringWrapper>,
2469 pub new_size: Option<StringWrapper>,
2470 }
2471
2472 #[derive(
2473 Clone,
2474 Debug,
2475 Default,
2476 PartialEq,
2477 Eq,
2478 PartialOrd,
2479 Ord,
2480 Serialize,
2481 Deserialize,
2482 Arbitrary
2483 )]
2484 pub struct AlterSetClusterV1 {
2485 pub id: String,
2486 pub name: Option<FullNameV1>,
2487 pub old_cluster: Option<StringWrapper>,
2488 pub new_cluster: Option<StringWrapper>,
2489 }
2490
2491 #[derive(
2492 Clone,
2493 Debug,
2494 Default,
2495 PartialEq,
2496 Eq,
2497 PartialOrd,
2498 Ord,
2499 Serialize,
2500 Deserialize,
2501 Arbitrary
2502 )]
2503 pub struct GrantRoleV1 {
2504 pub role_id: String,
2505 pub member_id: String,
2506 pub grantor_id: String,
2507 }
2508
2509 #[derive(
2510 Clone,
2511 Debug,
2512 Default,
2513 PartialEq,
2514 Eq,
2515 PartialOrd,
2516 Ord,
2517 Serialize,
2518 Deserialize,
2519 Arbitrary
2520 )]
2521 pub struct GrantRoleV2 {
2522 pub role_id: String,
2523 pub member_id: String,
2524 pub grantor_id: String,
2525 pub executed_by: String,
2526 }
2527
2528 #[derive(
2529 Clone,
2530 Debug,
2531 Default,
2532 PartialEq,
2533 Eq,
2534 PartialOrd,
2535 Ord,
2536 Serialize,
2537 Deserialize,
2538 Arbitrary
2539 )]
2540 pub struct RevokeRoleV1 {
2541 pub role_id: String,
2542 pub member_id: String,
2543 }
2544
2545 #[derive(
2546 Clone,
2547 Debug,
2548 Default,
2549 PartialEq,
2550 Eq,
2551 PartialOrd,
2552 Ord,
2553 Serialize,
2554 Deserialize,
2555 Arbitrary
2556 )]
2557 pub struct RevokeRoleV2 {
2558 pub role_id: String,
2559 pub member_id: String,
2560 pub grantor_id: String,
2561 pub executed_by: String,
2562 }
2563
2564 #[derive(
2565 Clone,
2566 Debug,
2567 Default,
2568 PartialEq,
2569 Eq,
2570 PartialOrd,
2571 Ord,
2572 Serialize,
2573 Deserialize,
2574 Arbitrary
2575 )]
2576 pub struct UpdatePrivilegeV1 {
2577 pub object_id: String,
2578 pub grantee_id: String,
2579 pub grantor_id: String,
2580 pub privileges: String,
2581 }
2582
2583 #[derive(
2584 Clone,
2585 Debug,
2586 Default,
2587 PartialEq,
2588 Eq,
2589 PartialOrd,
2590 Ord,
2591 Serialize,
2592 Deserialize,
2593 Arbitrary
2594 )]
2595 pub struct AlterDefaultPrivilegeV1 {
2596 pub role_id: String,
2597 pub database_id: Option<StringWrapper>,
2598 pub schema_id: Option<StringWrapper>,
2599 pub grantee_id: String,
2600 pub privileges: String,
2601 }
2602
2603 #[derive(
2604 Clone,
2605 Debug,
2606 Default,
2607 PartialEq,
2608 Eq,
2609 PartialOrd,
2610 Ord,
2611 Serialize,
2612 Deserialize,
2613 Arbitrary
2614 )]
2615 pub struct UpdateOwnerV1 {
2616 pub object_id: String,
2617 pub old_owner_id: String,
2618 pub new_owner_id: String,
2619 }
2620
2621 #[derive(
2622 Clone,
2623 Debug,
2624 Default,
2625 PartialEq,
2626 Eq,
2627 PartialOrd,
2628 Ord,
2629 Serialize,
2630 Deserialize,
2631 Arbitrary
2632 )]
2633 pub struct SchemaV1 {
2634 pub id: String,
2635 pub name: String,
2636 pub database_name: String,
2637 }
2638
2639 #[derive(
2640 Clone,
2641 Debug,
2642 Default,
2643 PartialEq,
2644 Eq,
2645 PartialOrd,
2646 Ord,
2647 Serialize,
2648 Deserialize,
2649 Arbitrary
2650 )]
2651 pub struct SchemaV2 {
2652 pub id: String,
2653 pub name: String,
2654 pub database_name: Option<StringWrapper>,
2655 }
2656
2657 #[derive(
2658 Clone,
2659 Debug,
2660 Default,
2661 PartialEq,
2662 Eq,
2663 PartialOrd,
2664 Ord,
2665 Serialize,
2666 Deserialize,
2667 Arbitrary
2668 )]
2669 pub struct RenameSchemaV1 {
2670 pub id: String,
2671 pub database_name: Option<String>,
2672 pub old_name: String,
2673 pub new_name: String,
2674 }
2675
2676 #[derive(
2677 Clone,
2678 Debug,
2679 Default,
2680 PartialEq,
2681 Eq,
2682 PartialOrd,
2683 Ord,
2684 Serialize,
2685 Deserialize,
2686 Arbitrary
2687 )]
2688 pub struct UpdateItemV1 {
2689 pub id: String,
2690 pub name: Option<FullNameV1>,
2691 }
2692
2693 #[derive(
2694 Clone,
2695 Debug,
2696 Default,
2697 PartialEq,
2698 Eq,
2699 PartialOrd,
2700 Ord,
2701 Serialize,
2702 Deserialize,
2703 Arbitrary
2704 )]
2705 pub struct AlterRetainHistoryV1 {
2706 pub id: String,
2707 pub old_history: Option<String>,
2708 pub new_history: Option<String>,
2709 }
2710
2711 #[derive(
2712 Clone,
2713 Debug,
2714 Default,
2715 PartialEq,
2716 Eq,
2717 PartialOrd,
2718 Ord,
2719 Serialize,
2720 Deserialize,
2721 Arbitrary
2722 )]
2723 pub struct ToNewIdV1 {
2724 pub id: String,
2725 pub new_id: 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 FromPreviousIdV1 {
2741 pub id: String,
2742 pub previous_id: String,
2743 }
2744
2745 #[derive(
2746 Clone,
2747 Debug,
2748 Default,
2749 PartialEq,
2750 Eq,
2751 PartialOrd,
2752 Ord,
2753 Serialize,
2754 Deserialize,
2755 Arbitrary
2756 )]
2757 pub struct SetV1 {
2758 pub name: String,
2759 pub value: Option<String>,
2760 }
2761
2762 #[derive(
2763 Clone,
2764 Debug,
2765 Default,
2766 PartialEq,
2767 Eq,
2768 PartialOrd,
2769 Ord,
2770 Serialize,
2771 Deserialize,
2772 Arbitrary
2773 )]
2774 pub struct RotateKeysV1 {
2775 pub id: String,
2776 pub name: String,
2777 }
2778
2779 #[derive(
2780 Clone,
2781 Copy,
2782 Debug,
2783 PartialEq,
2784 Eq,
2785 Hash,
2786 PartialOrd,
2787 Ord,
2788 Arbitrary,
2789 IntoPrimitive,
2790 TryFromPrimitive
2791 )]
2792 #[repr(i32)]
2793 pub enum EventType {
2794 Unknown = 0,
2795 Create = 1,
2796 Drop = 2,
2797 Alter = 3,
2798 Grant = 4,
2799 Revoke = 5,
2800 Comment = 6,
2801 }
2802
2803 #[derive(
2804 Clone,
2805 Copy,
2806 Debug,
2807 PartialEq,
2808 Eq,
2809 Hash,
2810 PartialOrd,
2811 Ord,
2812 Arbitrary,
2813 IntoPrimitive,
2814 TryFromPrimitive
2815 )]
2816 #[repr(i32)]
2817 pub enum ObjectType {
2818 Unknown = 0,
2819 Cluster = 1,
2820 ClusterReplica = 2,
2821 Connection = 3,
2822 Database = 4,
2823 Func = 5,
2824 Index = 6,
2825 MaterializedView = 7,
2826 Role = 8,
2827 Secret = 9,
2828 Schema = 10,
2829 Sink = 11,
2830 Source = 12,
2831 Table = 13,
2832 Type = 14,
2833 View = 15,
2834 System = 16,
2835 ContinualTask = 17,
2836 NetworkPolicy = 18,
2837 }
2838 #[derive(
2839 Clone,
2840 Debug,
2841 PartialEq,
2842 Eq,
2843 PartialOrd,
2844 Ord,
2845 Serialize,
2846 Deserialize,
2847 Arbitrary
2848 )]
2849 pub enum Details {
2850 CreateClusterReplicaV1(CreateClusterReplicaV1),
2851 CreateClusterReplicaV2(CreateClusterReplicaV2),
2852 CreateClusterReplicaV3(CreateClusterReplicaV3),
2853 DropClusterReplicaV1(DropClusterReplicaV1),
2854 DropClusterReplicaV2(DropClusterReplicaV2),
2855 DropClusterReplicaV3(DropClusterReplicaV3),
2856 CreateSourceSinkV1(CreateSourceSinkV1),
2857 CreateSourceSinkV2(CreateSourceSinkV2),
2858 AlterSourceSinkV1(AlterSourceSinkV1),
2859 AlterSetClusterV1(AlterSetClusterV1),
2860 GrantRoleV1(GrantRoleV1),
2861 GrantRoleV2(GrantRoleV2),
2862 RevokeRoleV1(RevokeRoleV1),
2863 RevokeRoleV2(RevokeRoleV2),
2864 UpdatePrivilegeV1(UpdatePrivilegeV1),
2865 AlterDefaultPrivilegeV1(AlterDefaultPrivilegeV1),
2866 UpdateOwnerV1(UpdateOwnerV1),
2867 IdFullNameV1(IdFullNameV1),
2868 RenameClusterV1(RenameClusterV1),
2869 RenameClusterReplicaV1(RenameClusterReplicaV1),
2870 RenameItemV1(RenameItemV1),
2871 IdNameV1(IdNameV1),
2872 SchemaV1(SchemaV1),
2873 SchemaV2(SchemaV2),
2874 RenameSchemaV1(RenameSchemaV1),
2875 UpdateItemV1(UpdateItemV1),
2876 CreateSourceSinkV3(CreateSourceSinkV3),
2877 AlterRetainHistoryV1(AlterRetainHistoryV1),
2878 ToNewIdV1(ToNewIdV1),
2879 FromPreviousIdV1(FromPreviousIdV1),
2880 SetV1(SetV1),
2881 ResetAllV1(Empty),
2882 RotateKeysV1(RotateKeysV1),
2883 CreateSourceSinkV4(CreateSourceSinkV4),
2884 CreateIndexV1(CreateIndexV1),
2885 CreateMaterializedViewV1(CreateMaterializedViewV1),
2886 }
2887}
2888
2889#[derive(
2890 Clone,
2891 Debug,
2892 Default,
2893 PartialEq,
2894 Eq,
2895 PartialOrd,
2896 Ord,
2897 Serialize,
2898 Deserialize,
2899 Arbitrary
2900)]
2901pub struct StateUpdateKind {
2902 pub kind: Option<state_update_kind::Kind>,
2903}
2904
2905pub mod state_update_kind {
2906 use super::*;
2907
2908 #[derive(
2909 Clone,
2910 Debug,
2911 Default,
2912 PartialEq,
2913 Eq,
2914 PartialOrd,
2915 Ord,
2916 Serialize,
2917 Deserialize,
2918 Arbitrary
2919 )]
2920 pub struct AuditLog {
2921 pub key: Option<AuditLogKey>,
2922 }
2923
2924 #[derive(
2925 Clone,
2926 Debug,
2927 Default,
2928 PartialEq,
2929 Eq,
2930 PartialOrd,
2931 Ord,
2932 Serialize,
2933 Deserialize,
2934 Arbitrary
2935 )]
2936 pub struct Cluster {
2937 pub key: Option<ClusterKey>,
2938 pub value: Option<ClusterValue>,
2939 }
2940
2941 #[derive(
2942 Clone,
2943 Debug,
2944 Default,
2945 PartialEq,
2946 Eq,
2947 PartialOrd,
2948 Ord,
2949 Serialize,
2950 Deserialize,
2951 Arbitrary
2952 )]
2953 pub struct ClusterReplica {
2954 pub key: Option<ClusterReplicaKey>,
2955 pub value: Option<ClusterReplicaValue>,
2956 }
2957
2958 #[derive(
2959 Clone,
2960 Debug,
2961 Default,
2962 PartialEq,
2963 Eq,
2964 PartialOrd,
2965 Ord,
2966 Serialize,
2967 Deserialize,
2968 Arbitrary
2969 )]
2970 pub struct Comment {
2971 pub key: Option<CommentKey>,
2972 pub value: Option<CommentValue>,
2973 }
2974
2975 #[derive(
2976 Clone,
2977 Debug,
2978 Default,
2979 PartialEq,
2980 Eq,
2981 PartialOrd,
2982 Ord,
2983 Serialize,
2984 Deserialize,
2985 Arbitrary
2986 )]
2987 pub struct Config {
2988 pub key: Option<ConfigKey>,
2989 pub value: Option<ConfigValue>,
2990 }
2991
2992 #[derive(
2993 Clone,
2994 Debug,
2995 Default,
2996 PartialEq,
2997 Eq,
2998 PartialOrd,
2999 Ord,
3000 Serialize,
3001 Deserialize,
3002 Arbitrary
3003 )]
3004 pub struct Database {
3005 pub key: Option<DatabaseKey>,
3006 pub value: Option<DatabaseValue>,
3007 }
3008
3009 #[derive(
3010 Clone,
3011 Copy,
3012 Debug,
3013 Default,
3014 PartialEq,
3015 Eq,
3016 PartialOrd,
3017 Ord,
3018 Serialize,
3019 Deserialize,
3020 Arbitrary
3021 )]
3022 pub struct DefaultPrivileges {
3023 pub key: Option<DefaultPrivilegesKey>,
3024 pub value: Option<DefaultPrivilegesValue>,
3025 }
3026
3027 #[derive(
3028 Clone,
3029 Copy,
3030 Debug,
3031 Default,
3032 PartialEq,
3033 Eq,
3034 PartialOrd,
3035 Ord,
3036 Serialize,
3037 Deserialize,
3038 Arbitrary
3039 )]
3040 pub struct FenceToken {
3041 pub deploy_generation: u64,
3042 pub epoch: i64,
3043 }
3044
3045 #[derive(
3046 Clone,
3047 Debug,
3048 Default,
3049 PartialEq,
3050 Eq,
3051 PartialOrd,
3052 Ord,
3053 Serialize,
3054 Deserialize,
3055 Arbitrary
3056 )]
3057 pub struct IdAlloc {
3058 pub key: Option<IdAllocKey>,
3059 pub value: Option<IdAllocValue>,
3060 }
3061
3062 #[derive(
3063 Clone,
3064 Debug,
3065 Default,
3066 PartialEq,
3067 Eq,
3068 PartialOrd,
3069 Ord,
3070 Serialize,
3071 Deserialize,
3072 Arbitrary
3073 )]
3074 pub struct ClusterIntrospectionSourceIndex {
3075 pub key: Option<ClusterIntrospectionSourceIndexKey>,
3076 pub value: Option<ClusterIntrospectionSourceIndexValue>,
3077 }
3078
3079 #[derive(
3080 Clone,
3081 Debug,
3082 Default,
3083 PartialEq,
3084 Eq,
3085 PartialOrd,
3086 Ord,
3087 Serialize,
3088 Deserialize,
3089 Arbitrary
3090 )]
3091 pub struct Item {
3092 pub key: Option<ItemKey>,
3093 pub value: Option<ItemValue>,
3094 }
3095
3096 #[derive(
3097 Clone,
3098 Debug,
3099 Default,
3100 PartialEq,
3101 Eq,
3102 PartialOrd,
3103 Ord,
3104 Serialize,
3105 Deserialize,
3106 Arbitrary
3107 )]
3108 pub struct Role {
3109 pub key: Option<RoleKey>,
3110 pub value: Option<RoleValue>,
3111 }
3112
3113 #[derive(
3114 Clone,
3115 Debug,
3116 Default,
3117 PartialEq,
3118 Eq,
3119 PartialOrd,
3120 Ord,
3121 Serialize,
3122 Deserialize,
3123 Arbitrary
3124 )]
3125 pub struct RoleAuth {
3126 pub key: Option<RoleAuthKey>,
3127 pub value: Option<RoleAuthValue>,
3128 }
3129
3130 #[derive(
3131 Clone,
3132 Debug,
3133 Default,
3134 PartialEq,
3135 Eq,
3136 PartialOrd,
3137 Ord,
3138 Serialize,
3139 Deserialize,
3140 Arbitrary
3141 )]
3142 pub struct NetworkPolicy {
3143 pub key: Option<NetworkPolicyKey>,
3144 pub value: Option<NetworkPolicyValue>,
3145 }
3146
3147 #[derive(
3148 Clone,
3149 Debug,
3150 Default,
3151 PartialEq,
3152 Eq,
3153 PartialOrd,
3154 Ord,
3155 Serialize,
3156 Deserialize,
3157 Arbitrary
3158 )]
3159 pub struct Schema {
3160 pub key: Option<SchemaKey>,
3161 pub value: Option<SchemaValue>,
3162 }
3163
3164 #[derive(
3165 Clone,
3166 Debug,
3167 Default,
3168 PartialEq,
3169 Eq,
3170 PartialOrd,
3171 Ord,
3172 Serialize,
3173 Deserialize,
3174 Arbitrary
3175 )]
3176 pub struct Setting {
3177 pub key: Option<SettingKey>,
3178 pub value: Option<SettingValue>,
3179 }
3180
3181 #[derive(
3182 Clone,
3183 Debug,
3184 Default,
3185 PartialEq,
3186 Eq,
3187 PartialOrd,
3188 Ord,
3189 Serialize,
3190 Deserialize,
3191 Arbitrary
3192 )]
3193 pub struct ServerConfiguration {
3194 pub key: Option<ServerConfigurationKey>,
3195 pub value: Option<ServerConfigurationValue>,
3196 }
3197
3198 #[derive(
3199 Clone,
3200 Debug,
3201 Default,
3202 PartialEq,
3203 Eq,
3204 PartialOrd,
3205 Ord,
3206 Serialize,
3207 Deserialize,
3208 Arbitrary
3209 )]
3210 pub struct SourceReferences {
3211 pub key: Option<SourceReferencesKey>,
3212 pub value: Option<SourceReferencesValue>,
3213 }
3214
3215 #[derive(
3216 Clone,
3217 Debug,
3218 Default,
3219 PartialEq,
3220 Eq,
3221 PartialOrd,
3222 Ord,
3223 Serialize,
3224 Deserialize,
3225 Arbitrary
3226 )]
3227 pub struct GidMapping {
3228 pub key: Option<GidMappingKey>,
3229 pub value: Option<GidMappingValue>,
3230 }
3231
3232 #[derive(
3233 Clone,
3234 Copy,
3235 Debug,
3236 Default,
3237 PartialEq,
3238 Eq,
3239 PartialOrd,
3240 Ord,
3241 Serialize,
3242 Deserialize,
3243 Arbitrary
3244 )]
3245 pub struct SystemPrivileges {
3246 pub key: Option<SystemPrivilegesKey>,
3247 pub value: Option<SystemPrivilegesValue>,
3248 }
3249
3250 #[derive(
3251 Clone,
3252 Debug,
3253 Default,
3254 PartialEq,
3255 Eq,
3256 PartialOrd,
3257 Ord,
3258 Serialize,
3259 Deserialize,
3260 Arbitrary
3261 )]
3262 pub struct StorageCollectionMetadata {
3263 pub key: Option<StorageCollectionMetadataKey>,
3264 pub value: Option<StorageCollectionMetadataValue>,
3265 }
3266
3267 #[derive(
3268 Clone,
3269 Debug,
3270 Default,
3271 PartialEq,
3272 Eq,
3273 PartialOrd,
3274 Ord,
3275 Serialize,
3276 Deserialize,
3277 Arbitrary
3278 )]
3279 pub struct UnfinalizedShard {
3280 pub key: Option<UnfinalizedShardKey>,
3281 }
3282
3283 #[derive(
3284 Clone,
3285 Debug,
3286 Default,
3287 PartialEq,
3288 Eq,
3289 PartialOrd,
3290 Ord,
3291 Serialize,
3292 Deserialize,
3293 Arbitrary
3294 )]
3295 pub struct TxnWalShard {
3296 pub value: Option<TxnWalShardValue>,
3297 }
3298
3299 #[derive(
3300 Clone,
3301 Debug,
3302 PartialEq,
3303 Eq,
3304 PartialOrd,
3305 Ord,
3306 Serialize,
3307 Deserialize,
3308 Arbitrary
3309 )]
3310 #[serde(tag = "kind")]
3313 pub enum Kind {
3314 AuditLog(AuditLog),
3315 Cluster(Cluster),
3316 ClusterReplica(ClusterReplica),
3317 Comment(Comment),
3318 Config(Config),
3319 Database(Database),
3320 DefaultPrivileges(DefaultPrivileges),
3321 IdAlloc(IdAlloc),
3322 ClusterIntrospectionSourceIndex(ClusterIntrospectionSourceIndex),
3323 Item(Item),
3324 Role(Role),
3325 Schema(Schema),
3326 Setting(Setting),
3327 ServerConfiguration(ServerConfiguration),
3328 GidMapping(GidMapping),
3329 SystemPrivileges(SystemPrivileges),
3330 StorageCollectionMetadata(StorageCollectionMetadata),
3331 UnfinalizedShard(UnfinalizedShard),
3332 TxnWalShard(TxnWalShard),
3333 SourceReferences(SourceReferences),
3334 FenceToken(FenceToken),
3335 NetworkPolicy(NetworkPolicy),
3336 RoleAuth(RoleAuth),
3337 }
3338}
3339
3340#[derive(
3341 Clone,
3342 Copy,
3343 Debug,
3344 PartialEq,
3345 Eq,
3346 Hash,
3347 PartialOrd,
3348 Ord,
3349 Arbitrary,
3350 IntoPrimitive,
3351 TryFromPrimitive
3352)]
3353#[repr(i32)]
3354pub enum CatalogItemType {
3355 Unknown = 0,
3356 Table = 1,
3357 Source = 2,
3358 Sink = 3,
3359 View = 4,
3360 MaterializedView = 5,
3361 Index = 6,
3362 Type = 7,
3363 Func = 8,
3364 Secret = 9,
3365 Connection = 10,
3366 ContinualTask = 11,
3367}
3368
3369#[derive(
3370 Clone,
3371 Copy,
3372 Debug,
3373 PartialEq,
3374 Eq,
3375 Hash,
3376 PartialOrd,
3377 Ord,
3378 Arbitrary,
3379 IntoPrimitive,
3380 TryFromPrimitive
3381)]
3382#[repr(i32)]
3383pub enum ObjectType {
3384 Unknown = 0,
3385 Table = 1,
3386 View = 2,
3387 MaterializedView = 3,
3388 Source = 4,
3389 Sink = 5,
3390 Index = 6,
3391 Type = 7,
3392 Role = 8,
3393 Cluster = 9,
3394 ClusterReplica = 10,
3395 Secret = 11,
3396 Connection = 12,
3397 Database = 13,
3398 Schema = 14,
3399 Func = 15,
3400 ContinualTask = 16,
3401 NetworkPolicy = 17,
3402}