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