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