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 ContinualTask(CatalogItemId),
569 Role(RoleId),
570 Database(DatabaseId),
571 Schema(ResolvedSchema),
572 Cluster(ClusterId),
573 ClusterReplica(ClusterReplicaId),
574 NetworkPolicy(NetworkPolicyId),
575}
576
577#[derive(
578 Clone,
579 Copy,
580 Debug,
581 PartialEq,
582 Eq,
583 PartialOrd,
584 Ord,
585 Serialize,
586 Deserialize,
587 Arbitrary
588)]
589pub enum CommentSubComponent {
590 ColumnPos(u64),
591}
592
593#[derive(
594 Clone,
595 Debug,
596 PartialEq,
597 Eq,
598 PartialOrd,
599 Ord,
600 Serialize,
601 Deserialize,
602 Arbitrary
603)]
604pub struct CommentValue {
605 pub comment: String,
606}
607
608#[derive(
609 Clone,
610 Copy,
611 Debug,
612 PartialEq,
613 Eq,
614 PartialOrd,
615 Ord,
616 Serialize,
617 Deserialize,
618 Arbitrary
619)]
620pub struct SourceReferencesKey {
621 pub source: CatalogItemId,
622}
623
624#[derive(
625 Clone,
626 Debug,
627 PartialEq,
628 Eq,
629 PartialOrd,
630 Ord,
631 Serialize,
632 Deserialize,
633 Arbitrary
634)]
635pub struct SourceReferencesValue {
636 pub references: Vec<SourceReference>,
637 pub updated_at: EpochMillis,
638}
639
640#[derive(
641 Clone,
642 Debug,
643 PartialEq,
644 Eq,
645 PartialOrd,
646 Ord,
647 Serialize,
648 Deserialize,
649 Arbitrary
650)]
651pub struct SourceReference {
652 pub name: String,
653 pub namespace: Option<String>,
654 pub columns: Vec<String>,
655}
656
657#[derive(
658 Clone,
659 Copy,
660 Debug,
661 PartialEq,
662 Eq,
663 PartialOrd,
664 Ord,
665 Serialize,
666 Deserialize,
667 Arbitrary
668)]
669pub struct StorageCollectionMetadataKey {
670 pub id: GlobalId,
671}
672
673#[derive(
674 Clone,
675 Debug,
676 PartialEq,
677 Eq,
678 PartialOrd,
679 Ord,
680 Serialize,
681 Deserialize,
682 Arbitrary
683)]
684pub struct StorageCollectionMetadataValue {
685 pub shard: String,
686}
687
688#[derive(
689 Clone,
690 Debug,
691 PartialEq,
692 Eq,
693 PartialOrd,
694 Ord,
695 Serialize,
696 Deserialize,
697 Arbitrary
698)]
699pub struct UnfinalizedShardKey {
700 pub shard: String,
701}
702
703#[derive(
704 Clone,
705 Debug,
706 PartialEq,
707 Eq,
708 PartialOrd,
709 Ord,
710 Serialize,
711 Deserialize,
712 Arbitrary
713)]
714pub struct TxnWalShardValue {
715 pub shard: String,
716}
717
718#[derive(
719 Clone,
720 Copy,
721 Debug,
722 PartialEq,
723 Eq,
724 PartialOrd,
725 Ord,
726 Serialize,
727 Deserialize,
728 Arbitrary
729)]
730pub struct Empty {}
731
732#[derive(
733 Clone,
734 Debug,
735 PartialEq,
736 Eq,
737 PartialOrd,
738 Ord,
739 Serialize,
740 Deserialize,
741 Arbitrary
742)]
743pub struct StringWrapper {
744 pub inner: String,
745}
746
747#[derive(
748 Clone,
749 Copy,
750 Debug,
751 PartialEq,
752 Eq,
753 PartialOrd,
754 Ord,
755 Serialize,
756 Deserialize,
757 Arbitrary
758)]
759pub struct Duration {
760 pub secs: u64,
761 pub nanos: u32,
762}
763
764#[derive(
765 Clone,
766 Copy,
767 Debug,
768 PartialEq,
769 Eq,
770 PartialOrd,
771 Ord,
772 Serialize,
773 Deserialize,
774 Arbitrary
775)]
776pub struct EpochMillis {
777 pub millis: u64,
778}
779
780#[derive(
781 Clone,
782 Copy,
783 Debug,
784 PartialEq,
785 Eq,
786 PartialOrd,
787 Ord,
788 Serialize,
789 Deserialize,
790 Arbitrary
791)]
792pub struct Version {
793 pub value: u64,
794}
795
796#[derive(
797 Clone,
798 Debug,
799 PartialEq,
800 Eq,
801 PartialOrd,
802 Ord,
803 Serialize,
804 Deserialize,
805 Arbitrary
806)]
807pub enum CatalogItem {
808 V1(CatalogItemV1),
809}
810
811#[derive(
812 Clone,
813 Debug,
814 PartialEq,
815 Eq,
816 PartialOrd,
817 Ord,
818 Serialize,
819 Deserialize,
820 Arbitrary
821)]
822pub struct CatalogItemV1 {
823 pub create_sql: String,
824}
825
826#[derive(
827 Clone,
828 Copy,
829 Debug,
830 PartialEq,
831 Eq,
832 PartialOrd,
833 Ord,
834 Serialize,
835 Deserialize,
836 Arbitrary
837)]
838pub enum CatalogItemId {
839 System(u64),
840 User(u64),
841 Transient(u64),
842 IntrospectionSourceIndex(u64),
843}
844
845#[derive(
846 Clone,
847 Copy,
848 Debug,
849 PartialEq,
850 Eq,
851 PartialOrd,
852 Ord,
853 Serialize,
854 Deserialize,
855 Arbitrary
856)]
857pub struct SystemCatalogItemId(pub u64);
858
859#[derive(
860 Clone,
861 Copy,
862 Debug,
863 PartialEq,
864 Eq,
865 PartialOrd,
866 Ord,
867 Serialize,
868 Deserialize,
869 Arbitrary
870)]
871pub struct IntrospectionSourceIndexCatalogItemId(pub u64);
872
873#[derive(
874 Clone,
875 Copy,
876 Debug,
877 PartialEq,
878 Eq,
879 PartialOrd,
880 Ord,
881 Serialize,
882 Deserialize,
883 Arbitrary
884)]
885pub enum GlobalId {
886 System(u64),
887 User(u64),
888 Transient(u64),
889 Explain,
890 IntrospectionSourceIndex(u64),
891}
892
893#[derive(
894 Clone,
895 Copy,
896 Debug,
897 PartialEq,
898 Eq,
899 PartialOrd,
900 Ord,
901 Serialize,
902 Deserialize,
903 Arbitrary
904)]
905pub struct SystemGlobalId(pub u64);
906
907#[derive(
908 Clone,
909 Copy,
910 Debug,
911 PartialEq,
912 Eq,
913 PartialOrd,
914 Ord,
915 Serialize,
916 Deserialize,
917 Arbitrary
918)]
919pub struct IntrospectionSourceIndexGlobalId(pub u64);
920
921#[derive(
922 Clone,
923 Copy,
924 Debug,
925 PartialEq,
926 Eq,
927 PartialOrd,
928 Ord,
929 Serialize,
930 Deserialize,
931 Arbitrary
932)]
933pub enum ClusterId {
934 System(u64),
935 User(u64),
936}
937
938#[derive(
939 Clone,
940 Copy,
941 Debug,
942 PartialEq,
943 Eq,
944 PartialOrd,
945 Ord,
946 Serialize,
947 Deserialize,
948 Arbitrary
949)]
950pub enum DatabaseId {
951 System(u64),
952 User(u64),
953}
954
955#[derive(
956 Clone,
957 Copy,
958 Debug,
959 PartialEq,
960 Eq,
961 PartialOrd,
962 Ord,
963 Serialize,
964 Deserialize,
965 Arbitrary
966)]
967pub enum ResolvedDatabaseSpecifier {
968 Ambient,
969 Id(DatabaseId),
970}
971
972#[derive(
973 Clone,
974 Copy,
975 Debug,
976 PartialEq,
977 Eq,
978 PartialOrd,
979 Ord,
980 Serialize,
981 Deserialize,
982 Arbitrary
983)]
984pub enum SchemaId {
985 System(u64),
986 User(u64),
987}
988
989#[derive(
990 Clone,
991 Copy,
992 Debug,
993 PartialEq,
994 Eq,
995 PartialOrd,
996 Ord,
997 Serialize,
998 Deserialize,
999 Arbitrary
1000)]
1001pub enum SchemaSpecifier {
1002 Temporary,
1003 Id(SchemaId),
1004}
1005
1006#[derive(
1007 Clone,
1008 Copy,
1009 Debug,
1010 PartialEq,
1011 Eq,
1012 PartialOrd,
1013 Ord,
1014 Serialize,
1015 Deserialize,
1016 Arbitrary
1017)]
1018pub struct ResolvedSchema {
1019 pub database: ResolvedDatabaseSpecifier,
1020 pub schema: SchemaSpecifier,
1021}
1022
1023#[derive(
1024 Clone,
1025 Copy,
1026 Debug,
1027 PartialEq,
1028 Eq,
1029 PartialOrd,
1030 Ord,
1031 Serialize,
1032 Deserialize,
1033 Arbitrary
1034)]
1035pub enum ReplicaId {
1036 System(u64),
1037 User(u64),
1038}
1039
1040#[derive(
1041 Clone,
1042 Copy,
1043 Debug,
1044 PartialEq,
1045 Eq,
1046 PartialOrd,
1047 Ord,
1048 Serialize,
1049 Deserialize,
1050 Arbitrary
1051)]
1052pub struct ClusterReplicaId {
1053 pub cluster_id: ClusterId,
1054 pub replica_id: ReplicaId,
1055}
1056
1057#[derive(
1058 Clone,
1059 Copy,
1060 Debug,
1061 PartialEq,
1062 Eq,
1063 PartialOrd,
1064 Ord,
1065 Serialize,
1066 Deserialize,
1067 Arbitrary
1068)]
1069pub enum NetworkPolicyId {
1070 System(u64),
1071 User(u64),
1072}
1073
1074#[derive(
1075 Clone,
1076 Copy,
1077 Debug,
1078 PartialEq,
1079 Eq,
1080 PartialOrd,
1081 Ord,
1082 Serialize,
1083 Deserialize,
1084 Arbitrary
1085)]
1086pub struct ReplicaLogging {
1087 pub log_logging: bool,
1088 pub interval: Option<Duration>,
1089}
1090
1091#[derive(
1092 Clone,
1093 Debug,
1094 PartialEq,
1095 Eq,
1096 PartialOrd,
1097 Ord,
1098 Serialize,
1099 Deserialize,
1100 Arbitrary
1101)]
1102pub struct OptimizerFeatureOverride {
1103 pub name: String,
1104 pub value: String,
1105}
1106
1107#[derive(
1108 Clone,
1109 Copy,
1110 Debug,
1111 PartialEq,
1112 Eq,
1113 PartialOrd,
1114 Ord,
1115 Serialize,
1116 Deserialize,
1117 Arbitrary
1118)]
1119pub struct ClusterScheduleRefreshOptions {
1120 pub rehydration_time_estimate: Duration,
1121}
1122
1123#[derive(
1124 Clone,
1125 Copy,
1126 Debug,
1127 PartialEq,
1128 Eq,
1129 PartialOrd,
1130 Ord,
1131 Serialize,
1132 Deserialize,
1133 Arbitrary
1134)]
1135pub enum ClusterSchedule {
1136 Manual,
1137 Refresh(ClusterScheduleRefreshOptions),
1138}
1139
1140#[derive(
1141 Clone,
1142 Debug,
1143 PartialEq,
1144 Eq,
1145 PartialOrd,
1146 Ord,
1147 Serialize,
1148 Deserialize,
1149 Arbitrary
1150)]
1151pub struct ClusterConfig {
1152 pub workload_class: Option<String>,
1153 pub variant: ClusterVariant,
1154}
1155
1156#[derive(
1157 Clone,
1158 Debug,
1159 PartialEq,
1160 Eq,
1161 PartialOrd,
1162 Ord,
1163 Serialize,
1164 Deserialize,
1165 Arbitrary
1166)]
1167pub enum ClusterVariant {
1168 Unmanaged,
1169 Managed(ManagedCluster),
1170}
1171
1172#[derive(
1173 Clone,
1174 Debug,
1175 PartialEq,
1176 Eq,
1177 PartialOrd,
1178 Ord,
1179 Serialize,
1180 Deserialize,
1181 Arbitrary
1182)]
1183pub struct ManagedCluster {
1184 pub size: String,
1185 pub replication_factor: u32,
1186 pub availability_zones: Vec<String>,
1187 pub logging: ReplicaLogging,
1188 pub optimizer_feature_overrides: Vec<OptimizerFeatureOverride>,
1189 pub schedule: ClusterSchedule,
1190}
1191
1192#[derive(
1193 Clone,
1194 Debug,
1195 PartialEq,
1196 Eq,
1197 PartialOrd,
1198 Ord,
1199 Serialize,
1200 Deserialize,
1201 Arbitrary
1202)]
1203pub struct ReplicaConfig {
1204 pub logging: ReplicaLogging,
1205 pub location: ReplicaLocation,
1206}
1207
1208#[derive(
1209 Clone,
1210 Debug,
1211 PartialEq,
1212 Eq,
1213 PartialOrd,
1214 Ord,
1215 Serialize,
1216 Deserialize,
1217 Arbitrary
1218)]
1219pub struct UnmanagedLocation {
1220 pub storagectl_addrs: Vec<String>,
1221 pub computectl_addrs: Vec<String>,
1222}
1223
1224#[derive(
1225 Clone,
1226 Debug,
1227 PartialEq,
1228 Eq,
1229 PartialOrd,
1230 Ord,
1231 Serialize,
1232 Deserialize,
1233 Arbitrary
1234)]
1235pub struct ManagedLocation {
1236 pub size: String,
1237 pub availability_zone: Option<String>,
1238 pub internal: bool,
1239 pub billed_as: Option<String>,
1240 pub pending: bool,
1241}
1242
1243#[derive(
1244 Clone,
1245 Debug,
1246 PartialEq,
1247 Eq,
1248 PartialOrd,
1249 Ord,
1250 Serialize,
1251 Deserialize,
1252 Arbitrary
1253)]
1254pub enum ReplicaLocation {
1255 Unmanaged(UnmanagedLocation),
1256 Managed(ManagedLocation),
1257}
1258
1259#[derive(
1260 Clone,
1261 Copy,
1262 Debug,
1263 PartialEq,
1264 Eq,
1265 PartialOrd,
1266 Ord,
1267 Serialize,
1268 Deserialize,
1269 Arbitrary
1270)]
1271pub enum RoleId {
1272 System(u64),
1273 User(u64),
1274 Public,
1275 Predefined(u64),
1276}
1277
1278#[derive(
1279 Clone,
1280 Copy,
1281 Debug,
1282 PartialEq,
1283 Eq,
1284 PartialOrd,
1285 Ord,
1286 Serialize,
1287 Deserialize,
1288 Arbitrary
1289)]
1290pub struct RoleAttributes {
1291 pub inherit: bool,
1292 pub superuser: Option<bool>,
1293 pub login: Option<bool>,
1294}
1295
1296#[derive(
1297 Clone,
1298 Debug,
1299 PartialEq,
1300 Eq,
1301 PartialOrd,
1302 Ord,
1303 Serialize,
1304 Deserialize,
1305 Arbitrary
1306)]
1307pub struct RoleMembership {
1308 pub map: Vec<RoleMembershipEntry>,
1309}
1310
1311#[derive(
1312 Clone,
1313 Copy,
1314 Debug,
1315 PartialEq,
1316 Eq,
1317 PartialOrd,
1318 Ord,
1319 Serialize,
1320 Deserialize,
1321 Arbitrary
1322)]
1323pub struct RoleMembershipEntry {
1324 pub key: RoleId,
1325 pub value: RoleId,
1326}
1327
1328#[derive(
1329 Clone,
1330 Debug,
1331 PartialEq,
1332 Eq,
1333 PartialOrd,
1334 Ord,
1335 Serialize,
1336 Deserialize,
1337 Arbitrary
1338)]
1339pub struct RoleVars {
1340 pub entries: Vec<RoleVarsEntry>,
1341}
1342
1343#[derive(
1344 Clone,
1345 Debug,
1346 PartialEq,
1347 Eq,
1348 PartialOrd,
1349 Ord,
1350 Serialize,
1351 Deserialize,
1352 Arbitrary
1353)]
1354pub struct RoleVarsEntry {
1355 pub key: String,
1356 pub val: RoleVar,
1357}
1358
1359#[derive(
1360 Clone,
1361 Debug,
1362 PartialEq,
1363 Eq,
1364 PartialOrd,
1365 Ord,
1366 Serialize,
1367 Deserialize,
1368 Arbitrary
1369)]
1370pub enum RoleVar {
1371 Flat(String),
1372 SqlSet(Vec<String>),
1373}
1374
1375#[derive(
1376 Clone,
1377 Debug,
1378 PartialEq,
1379 Eq,
1380 PartialOrd,
1381 Ord,
1382 Serialize,
1383 Deserialize,
1384 Arbitrary
1385)]
1386pub struct NetworkPolicyRule {
1387 pub name: String,
1388 pub address: String,
1389 pub action: NetworkPolicyRuleAction,
1390 pub direction: NetworkPolicyRuleDirection,
1391}
1392
1393#[derive(
1394 Clone,
1395 Copy,
1396 Debug,
1397 PartialEq,
1398 Eq,
1399 PartialOrd,
1400 Ord,
1401 Serialize,
1402 Deserialize,
1403 Arbitrary
1404)]
1405pub enum NetworkPolicyRuleAction {
1406 Allow,
1407}
1408
1409#[derive(
1410 Clone,
1411 Copy,
1412 Debug,
1413 PartialEq,
1414 Eq,
1415 PartialOrd,
1416 Ord,
1417 Serialize,
1418 Deserialize,
1419 Arbitrary
1420)]
1421pub enum NetworkPolicyRuleDirection {
1422 Ingress,
1423}
1424
1425#[derive(
1426 Clone,
1427 Copy,
1428 Debug,
1429 PartialEq,
1430 Eq,
1431 PartialOrd,
1432 Ord,
1433 Serialize,
1434 Deserialize,
1435 Arbitrary
1436)]
1437pub struct AclMode {
1438 pub bitflags: u64,
1439}
1440
1441#[derive(
1442 Clone,
1443 Copy,
1444 Debug,
1445 PartialEq,
1446 Eq,
1447 PartialOrd,
1448 Ord,
1449 Serialize,
1450 Deserialize,
1451 Arbitrary
1452)]
1453pub struct MzAclItem {
1454 pub grantee: RoleId,
1455 pub grantor: RoleId,
1456 pub acl_mode: AclMode,
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 DefaultPrivilegesKey {
1472 pub role_id: RoleId,
1473 pub database_id: Option<DatabaseId>,
1474 pub schema_id: Option<SchemaId>,
1475 pub object_type: ObjectType,
1476 pub grantee: RoleId,
1477}
1478
1479#[derive(
1480 Clone,
1481 Copy,
1482 Debug,
1483 PartialEq,
1484 Eq,
1485 PartialOrd,
1486 Ord,
1487 Serialize,
1488 Deserialize,
1489 Arbitrary
1490)]
1491pub struct DefaultPrivilegesValue {
1492 pub privileges: AclMode,
1493}
1494
1495#[derive(
1496 Clone,
1497 Copy,
1498 Debug,
1499 PartialEq,
1500 Eq,
1501 PartialOrd,
1502 Ord,
1503 Serialize,
1504 Deserialize,
1505 Arbitrary
1506)]
1507pub struct SystemPrivilegesKey {
1508 pub grantee: RoleId,
1509 pub grantor: RoleId,
1510}
1511
1512#[derive(
1513 Clone,
1514 Copy,
1515 Debug,
1516 PartialEq,
1517 Eq,
1518 PartialOrd,
1519 Ord,
1520 Serialize,
1521 Deserialize,
1522 Arbitrary
1523)]
1524pub struct SystemPrivilegesValue {
1525 pub acl_mode: AclMode,
1526}
1527
1528#[derive(
1529 Clone,
1530 Debug,
1531 PartialEq,
1532 Eq,
1533 PartialOrd,
1534 Ord,
1535 Serialize,
1536 Deserialize,
1537 Arbitrary
1538)]
1539pub struct AuditLogEventV1 {
1540 pub id: u64,
1541 pub event_type: audit_log_event_v1::EventType,
1542 pub object_type: audit_log_event_v1::ObjectType,
1543 pub user: Option<StringWrapper>,
1544 pub occurred_at: EpochMillis,
1545 pub details: audit_log_event_v1::Details,
1546}
1547
1548pub mod audit_log_event_v1 {
1549 use super::*;
1550
1551 #[derive(
1552 Clone,
1553 Debug,
1554 PartialEq,
1555 Eq,
1556 PartialOrd,
1557 Ord,
1558 Serialize,
1559 Deserialize,
1560 Arbitrary
1561 )]
1562 pub struct IdFullNameV1 {
1563 pub id: String,
1564 pub name: FullNameV1,
1565 }
1566
1567 #[derive(
1568 Clone,
1569 Debug,
1570 PartialEq,
1571 Eq,
1572 PartialOrd,
1573 Ord,
1574 Serialize,
1575 Deserialize,
1576 Arbitrary
1577 )]
1578 pub struct FullNameV1 {
1579 pub database: String,
1580 pub schema: String,
1581 pub item: String,
1582 }
1583
1584 #[derive(
1585 Clone,
1586 Debug,
1587 PartialEq,
1588 Eq,
1589 PartialOrd,
1590 Ord,
1591 Serialize,
1592 Deserialize,
1593 Arbitrary
1594 )]
1595 pub struct IdNameV1 {
1596 pub id: String,
1597 pub name: String,
1598 }
1599
1600 #[derive(
1601 Clone,
1602 Debug,
1603 PartialEq,
1604 Eq,
1605 PartialOrd,
1606 Ord,
1607 Serialize,
1608 Deserialize,
1609 Arbitrary
1610 )]
1611 pub struct RenameClusterV1 {
1612 pub id: String,
1613 pub old_name: String,
1614 pub new_name: String,
1615 }
1616
1617 #[derive(
1618 Clone,
1619 Debug,
1620 PartialEq,
1621 Eq,
1622 PartialOrd,
1623 Ord,
1624 Serialize,
1625 Deserialize,
1626 Arbitrary
1627 )]
1628 pub struct RenameClusterReplicaV1 {
1629 pub cluster_id: String,
1630 pub replica_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 RenameItemV1 {
1647 pub id: String,
1648 pub old_name: FullNameV1,
1649 pub new_name: FullNameV1,
1650 }
1651
1652 #[derive(
1653 Clone,
1654 Debug,
1655 PartialEq,
1656 Eq,
1657 PartialOrd,
1658 Ord,
1659 Serialize,
1660 Deserialize,
1661 Arbitrary
1662 )]
1663 pub struct CreateClusterReplicaV1 {
1664 pub cluster_id: String,
1665 pub cluster_name: String,
1666 pub replica_id: Option<StringWrapper>,
1667 pub replica_name: String,
1668 pub logical_size: String,
1669 pub disk: bool,
1670 pub billed_as: Option<String>,
1671 pub internal: bool,
1672 }
1673
1674 #[derive(
1675 Clone,
1676 Debug,
1677 PartialEq,
1678 Eq,
1679 PartialOrd,
1680 Ord,
1681 Serialize,
1682 Deserialize,
1683 Arbitrary
1684 )]
1685 pub struct CreateClusterReplicaV2 {
1686 pub cluster_id: String,
1687 pub cluster_name: String,
1688 pub replica_id: Option<StringWrapper>,
1689 pub replica_name: String,
1690 pub logical_size: String,
1691 pub disk: bool,
1692 pub billed_as: Option<String>,
1693 pub internal: bool,
1694 pub reason: CreateOrDropClusterReplicaReasonV1,
1695 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV1>,
1696 }
1697
1698 #[derive(
1699 Clone,
1700 Debug,
1701 PartialEq,
1702 Eq,
1703 PartialOrd,
1704 Ord,
1705 Serialize,
1706 Deserialize,
1707 Arbitrary
1708 )]
1709 pub struct CreateClusterReplicaV3 {
1710 pub cluster_id: String,
1711 pub cluster_name: String,
1712 pub replica_id: Option<StringWrapper>,
1713 pub replica_name: String,
1714 pub logical_size: String,
1715 pub disk: bool,
1716 pub billed_as: Option<String>,
1717 pub internal: bool,
1718 pub reason: CreateOrDropClusterReplicaReasonV1,
1719 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
1720 }
1721
1722 #[derive(
1723 Clone,
1724 Debug,
1725 PartialEq,
1726 Eq,
1727 PartialOrd,
1728 Ord,
1729 Serialize,
1730 Deserialize,
1731 Arbitrary
1732 )]
1733 pub struct CreateClusterReplicaV4 {
1734 pub cluster_id: String,
1735 pub cluster_name: String,
1736 pub replica_id: Option<StringWrapper>,
1737 pub replica_name: String,
1738 pub logical_size: String,
1739 pub billed_as: Option<String>,
1740 pub internal: bool,
1741 pub reason: CreateOrDropClusterReplicaReasonV1,
1742 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
1743 }
1744
1745 #[derive(
1746 Clone,
1747 Debug,
1748 PartialEq,
1749 Eq,
1750 PartialOrd,
1751 Ord,
1752 Serialize,
1753 Deserialize,
1754 Arbitrary
1755 )]
1756 pub struct DropClusterReplicaV1 {
1757 pub cluster_id: String,
1758 pub cluster_name: String,
1759 pub replica_id: Option<StringWrapper>,
1760 pub replica_name: String,
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 DropClusterReplicaV2 {
1775 pub cluster_id: String,
1776 pub cluster_name: String,
1777 pub replica_id: Option<StringWrapper>,
1778 pub replica_name: String,
1779 pub reason: CreateOrDropClusterReplicaReasonV1,
1780 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV1>,
1781 }
1782
1783 #[derive(
1784 Clone,
1785 Debug,
1786 PartialEq,
1787 Eq,
1788 PartialOrd,
1789 Ord,
1790 Serialize,
1791 Deserialize,
1792 Arbitrary
1793 )]
1794 pub struct DropClusterReplicaV3 {
1795 pub cluster_id: String,
1796 pub cluster_name: String,
1797 pub replica_id: Option<StringWrapper>,
1798 pub replica_name: String,
1799 pub reason: CreateOrDropClusterReplicaReasonV1,
1800 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
1801 }
1802
1803 #[derive(
1804 Clone,
1805 Copy,
1806 Debug,
1807 PartialEq,
1808 Eq,
1809 PartialOrd,
1810 Ord,
1811 Serialize,
1812 Deserialize,
1813 Arbitrary
1814 )]
1815 pub struct CreateOrDropClusterReplicaReasonV1 {
1816 pub reason: CreateOrDropClusterReplicaReasonV1Reason,
1817 }
1818
1819 #[derive(
1820 Clone,
1821 Copy,
1822 Debug,
1823 PartialEq,
1824 Eq,
1825 PartialOrd,
1826 Ord,
1827 Serialize,
1828 Deserialize,
1829 Arbitrary
1830 )]
1831 pub enum CreateOrDropClusterReplicaReasonV1Reason {
1832 Manual(Empty),
1833 Schedule(Empty),
1834 System(Empty),
1835 }
1836
1837 #[derive(
1838 Clone,
1839 Debug,
1840 PartialEq,
1841 Eq,
1842 PartialOrd,
1843 Ord,
1844 Serialize,
1845 Deserialize,
1846 Arbitrary
1847 )]
1848 pub struct SchedulingDecisionsWithReasonsV1 {
1849 pub on_refresh: RefreshDecisionWithReasonV1,
1850 }
1851
1852 #[derive(
1853 Clone,
1854 Debug,
1855 PartialEq,
1856 Eq,
1857 PartialOrd,
1858 Ord,
1859 Serialize,
1860 Deserialize,
1861 Arbitrary
1862 )]
1863 pub struct SchedulingDecisionsWithReasonsV2 {
1864 pub on_refresh: RefreshDecisionWithReasonV2,
1865 }
1866
1867 #[derive(
1868 Clone,
1869 Debug,
1870 PartialEq,
1871 Eq,
1872 PartialOrd,
1873 Ord,
1874 Serialize,
1875 Deserialize,
1876 Arbitrary
1877 )]
1878 pub enum RefreshDecision {
1879 On(Empty),
1880 Off(Empty),
1881 }
1882
1883 #[derive(
1884 Clone,
1885 Debug,
1886 PartialEq,
1887 Eq,
1888 PartialOrd,
1889 Ord,
1890 Serialize,
1891 Deserialize,
1892 Arbitrary
1893 )]
1894 pub struct RefreshDecisionWithReasonV1 {
1895 pub objects_needing_refresh: Vec<String>,
1896 pub rehydration_time_estimate: String,
1897 pub decision: RefreshDecision,
1898 }
1899
1900 #[derive(
1901 Clone,
1902 Debug,
1903 PartialEq,
1904 Eq,
1905 PartialOrd,
1906 Ord,
1907 Serialize,
1908 Deserialize,
1909 Arbitrary
1910 )]
1911 pub struct RefreshDecisionWithReasonV2 {
1912 pub objects_needing_refresh: Vec<String>,
1913 pub objects_needing_compaction: 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 CreateSourceSinkV1 {
1930 pub id: String,
1931 pub name: FullNameV1,
1932 pub size: Option<StringWrapper>,
1933 }
1934
1935 #[derive(
1936 Clone,
1937 Debug,
1938 PartialEq,
1939 Eq,
1940 PartialOrd,
1941 Ord,
1942 Serialize,
1943 Deserialize,
1944 Arbitrary
1945 )]
1946 pub struct CreateSourceSinkV2 {
1947 pub id: String,
1948 pub name: FullNameV1,
1949 pub size: Option<StringWrapper>,
1950 pub external_type: String,
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 CreateSourceSinkV3 {
1965 pub id: String,
1966 pub name: FullNameV1,
1967 pub external_type: String,
1968 }
1969
1970 #[derive(
1971 Clone,
1972 Debug,
1973 PartialEq,
1974 Eq,
1975 PartialOrd,
1976 Ord,
1977 Serialize,
1978 Deserialize,
1979 Arbitrary
1980 )]
1981 pub struct CreateSourceSinkV4 {
1982 pub id: String,
1983 pub cluster_id: Option<StringWrapper>,
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 CreateIndexV1 {
2000 pub id: String,
2001 pub cluster_id: String,
2002 pub name: FullNameV1,
2003 }
2004
2005 #[derive(
2006 Clone,
2007 Debug,
2008 PartialEq,
2009 Eq,
2010 PartialOrd,
2011 Ord,
2012 Serialize,
2013 Deserialize,
2014 Arbitrary
2015 )]
2016 pub struct CreateMaterializedViewV1 {
2017 pub id: String,
2018 pub cluster_id: String,
2019 pub name: FullNameV1,
2020 }
2021
2022 #[derive(
2023 Clone,
2024 Debug,
2025 PartialEq,
2026 Eq,
2027 PartialOrd,
2028 Ord,
2029 Serialize,
2030 Deserialize,
2031 Arbitrary
2032 )]
2033 pub struct AlterSourceSinkV1 {
2034 pub id: String,
2035 pub name: FullNameV1,
2036 pub old_size: Option<StringWrapper>,
2037 pub new_size: Option<StringWrapper>,
2038 }
2039
2040 #[derive(
2041 Clone,
2042 Debug,
2043 PartialEq,
2044 Eq,
2045 PartialOrd,
2046 Ord,
2047 Serialize,
2048 Deserialize,
2049 Arbitrary
2050 )]
2051 pub struct AlterSetClusterV1 {
2052 pub id: String,
2053 pub name: FullNameV1,
2054 pub old_cluster: Option<StringWrapper>,
2055 pub new_cluster: Option<StringWrapper>,
2056 }
2057
2058 #[derive(
2059 Clone,
2060 Debug,
2061 PartialEq,
2062 Eq,
2063 PartialOrd,
2064 Ord,
2065 Serialize,
2066 Deserialize,
2067 Arbitrary
2068 )]
2069 pub struct GrantRoleV1 {
2070 pub role_id: String,
2071 pub member_id: String,
2072 pub grantor_id: String,
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 GrantRoleV2 {
2087 pub role_id: String,
2088 pub member_id: String,
2089 pub grantor_id: String,
2090 pub executed_by: 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 RevokeRoleV1 {
2105 pub role_id: String,
2106 pub member_id: String,
2107 }
2108
2109 #[derive(
2110 Clone,
2111 Debug,
2112 PartialEq,
2113 Eq,
2114 PartialOrd,
2115 Ord,
2116 Serialize,
2117 Deserialize,
2118 Arbitrary
2119 )]
2120 pub struct RevokeRoleV2 {
2121 pub role_id: String,
2122 pub member_id: String,
2123 pub grantor_id: String,
2124 pub executed_by: String,
2125 }
2126
2127 #[derive(
2128 Clone,
2129 Debug,
2130 PartialEq,
2131 Eq,
2132 PartialOrd,
2133 Ord,
2134 Serialize,
2135 Deserialize,
2136 Arbitrary
2137 )]
2138 pub struct UpdatePrivilegeV1 {
2139 pub object_id: String,
2140 pub grantee_id: String,
2141 pub grantor_id: String,
2142 pub privileges: String,
2143 }
2144
2145 #[derive(
2146 Clone,
2147 Debug,
2148 PartialEq,
2149 Eq,
2150 PartialOrd,
2151 Ord,
2152 Serialize,
2153 Deserialize,
2154 Arbitrary
2155 )]
2156 pub struct AlterDefaultPrivilegeV1 {
2157 pub role_id: String,
2158 pub database_id: Option<StringWrapper>,
2159 pub schema_id: Option<StringWrapper>,
2160 pub grantee_id: String,
2161 pub privileges: String,
2162 }
2163
2164 #[derive(
2165 Clone,
2166 Debug,
2167 PartialEq,
2168 Eq,
2169 PartialOrd,
2170 Ord,
2171 Serialize,
2172 Deserialize,
2173 Arbitrary
2174 )]
2175 pub struct UpdateOwnerV1 {
2176 pub object_id: String,
2177 pub old_owner_id: String,
2178 pub new_owner_id: String,
2179 }
2180
2181 #[derive(
2182 Clone,
2183 Debug,
2184 PartialEq,
2185 Eq,
2186 PartialOrd,
2187 Ord,
2188 Serialize,
2189 Deserialize,
2190 Arbitrary
2191 )]
2192 pub struct SchemaV1 {
2193 pub id: String,
2194 pub name: String,
2195 pub database_name: String,
2196 }
2197
2198 #[derive(
2199 Clone,
2200 Debug,
2201 PartialEq,
2202 Eq,
2203 PartialOrd,
2204 Ord,
2205 Serialize,
2206 Deserialize,
2207 Arbitrary
2208 )]
2209 pub struct SchemaV2 {
2210 pub id: String,
2211 pub name: String,
2212 pub database_name: Option<StringWrapper>,
2213 }
2214
2215 #[derive(
2216 Clone,
2217 Debug,
2218 PartialEq,
2219 Eq,
2220 PartialOrd,
2221 Ord,
2222 Serialize,
2223 Deserialize,
2224 Arbitrary
2225 )]
2226 pub struct RenameSchemaV1 {
2227 pub id: String,
2228 pub database_name: Option<String>,
2229 pub old_name: String,
2230 pub new_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 UpdateItemV1 {
2245 pub id: String,
2246 pub name: FullNameV1,
2247 }
2248
2249 #[derive(
2250 Clone,
2251 Debug,
2252 PartialEq,
2253 Eq,
2254 PartialOrd,
2255 Ord,
2256 Serialize,
2257 Deserialize,
2258 Arbitrary
2259 )]
2260 pub struct AlterRetainHistoryV1 {
2261 pub id: String,
2262 pub old_history: Option<String>,
2263 pub new_history: Option<String>,
2264 }
2265
2266 #[derive(
2267 Clone,
2268 Debug,
2269 PartialEq,
2270 Eq,
2271 PartialOrd,
2272 Ord,
2273 Serialize,
2274 Deserialize,
2275 Arbitrary
2276 )]
2277 pub struct ToNewIdV1 {
2278 pub id: String,
2279 pub new_id: String,
2280 }
2281
2282 #[derive(
2283 Clone,
2284 Debug,
2285 PartialEq,
2286 Eq,
2287 PartialOrd,
2288 Ord,
2289 Serialize,
2290 Deserialize,
2291 Arbitrary
2292 )]
2293 pub struct FromPreviousIdV1 {
2294 pub id: String,
2295 pub previous_id: String,
2296 }
2297
2298 #[derive(
2299 Clone,
2300 Debug,
2301 PartialEq,
2302 Eq,
2303 PartialOrd,
2304 Ord,
2305 Serialize,
2306 Deserialize,
2307 Arbitrary
2308 )]
2309 pub struct SetV1 {
2310 pub name: String,
2311 pub value: Option<String>,
2312 }
2313
2314 #[derive(
2315 Clone,
2316 Debug,
2317 PartialEq,
2318 Eq,
2319 PartialOrd,
2320 Ord,
2321 Serialize,
2322 Deserialize,
2323 Arbitrary
2324 )]
2325 pub struct RotateKeysV1 {
2326 pub id: String,
2327 pub name: String,
2328 }
2329
2330 #[derive(
2331 Clone,
2332 Copy,
2333 Debug,
2334 PartialEq,
2335 Eq,
2336 Hash,
2337 PartialOrd,
2338 Ord,
2339 Serialize_repr,
2340 Deserialize_repr,
2341 Arbitrary
2342 )]
2343 #[repr(u8)]
2344 pub enum EventType {
2345 Unknown = 0,
2346 Create = 1,
2347 Drop = 2,
2348 Alter = 3,
2349 Grant = 4,
2350 Revoke = 5,
2351 Comment = 6,
2352 }
2353
2354 #[derive(
2355 Clone,
2356 Copy,
2357 Debug,
2358 PartialEq,
2359 Eq,
2360 Hash,
2361 PartialOrd,
2362 Ord,
2363 Serialize_repr,
2364 Deserialize_repr,
2365 Arbitrary
2366 )]
2367 #[repr(u8)]
2368 pub enum ObjectType {
2369 Unknown = 0,
2370 Cluster = 1,
2371 ClusterReplica = 2,
2372 Connection = 3,
2373 Database = 4,
2374 Func = 5,
2375 Index = 6,
2376 MaterializedView = 7,
2377 Role = 8,
2378 Secret = 9,
2379 Schema = 10,
2380 Sink = 11,
2381 Source = 12,
2382 Table = 13,
2383 Type = 14,
2384 View = 15,
2385 System = 16,
2386 ContinualTask = 17,
2387 NetworkPolicy = 18,
2388 }
2389
2390 #[derive(
2391 Clone,
2392 Debug,
2393 PartialEq,
2394 Eq,
2395 PartialOrd,
2396 Ord,
2397 Serialize,
2398 Deserialize,
2399 Arbitrary
2400 )]
2401 pub enum Details {
2402 CreateClusterReplicaV1(CreateClusterReplicaV1),
2403 CreateClusterReplicaV2(CreateClusterReplicaV2),
2404 CreateClusterReplicaV3(CreateClusterReplicaV3),
2405 CreateClusterReplicaV4(CreateClusterReplicaV4),
2406 DropClusterReplicaV1(DropClusterReplicaV1),
2407 DropClusterReplicaV2(DropClusterReplicaV2),
2408 DropClusterReplicaV3(DropClusterReplicaV3),
2409 CreateSourceSinkV1(CreateSourceSinkV1),
2410 CreateSourceSinkV2(CreateSourceSinkV2),
2411 AlterSourceSinkV1(AlterSourceSinkV1),
2412 AlterSetClusterV1(AlterSetClusterV1),
2413 GrantRoleV1(GrantRoleV1),
2414 GrantRoleV2(GrantRoleV2),
2415 RevokeRoleV1(RevokeRoleV1),
2416 RevokeRoleV2(RevokeRoleV2),
2417 UpdatePrivilegeV1(UpdatePrivilegeV1),
2418 AlterDefaultPrivilegeV1(AlterDefaultPrivilegeV1),
2419 UpdateOwnerV1(UpdateOwnerV1),
2420 IdFullNameV1(IdFullNameV1),
2421 RenameClusterV1(RenameClusterV1),
2422 RenameClusterReplicaV1(RenameClusterReplicaV1),
2423 RenameItemV1(RenameItemV1),
2424 IdNameV1(IdNameV1),
2425 SchemaV1(SchemaV1),
2426 SchemaV2(SchemaV2),
2427 RenameSchemaV1(RenameSchemaV1),
2428 UpdateItemV1(UpdateItemV1),
2429 CreateSourceSinkV3(CreateSourceSinkV3),
2430 AlterRetainHistoryV1(AlterRetainHistoryV1),
2431 ToNewIdV1(ToNewIdV1),
2432 FromPreviousIdV1(FromPreviousIdV1),
2433 SetV1(SetV1),
2434 ResetAllV1(Empty),
2435 RotateKeysV1(RotateKeysV1),
2436 CreateSourceSinkV4(CreateSourceSinkV4),
2437 CreateIndexV1(CreateIndexV1),
2438 CreateMaterializedViewV1(CreateMaterializedViewV1),
2439 }
2440}
2441
2442#[derive(
2444 Clone,
2445 Debug,
2446 PartialEq,
2447 Eq,
2448 PartialOrd,
2449 Ord,
2450 Serialize,
2451 Deserialize,
2452 Arbitrary
2453)]
2454#[serde(tag = "kind")]
2457pub enum StateUpdateKind {
2458 AuditLog(AuditLog),
2459 Cluster(Cluster),
2460 ClusterIntrospectionSourceIndex(ClusterIntrospectionSourceIndex),
2461 ClusterReplica(ClusterReplica),
2462 Comment(Comment),
2463 Config(Config),
2464 Database(Database),
2465 DefaultPrivileges(DefaultPrivileges),
2466 FenceToken(FenceToken),
2467 GidMapping(GidMapping),
2468 IdAlloc(IdAlloc),
2469 Item(Item),
2470 NetworkPolicy(NetworkPolicy),
2471 Role(Role),
2472 RoleAuth(RoleAuth),
2473 Schema(Schema),
2474 ServerConfiguration(ServerConfiguration),
2475 Setting(Setting),
2476 SourceReferences(SourceReferences),
2477 StorageCollectionMetadata(StorageCollectionMetadata),
2478 SystemPrivileges(SystemPrivileges),
2479 TxnWalShard(TxnWalShard),
2480 UnfinalizedShard(UnfinalizedShard),
2481}
2482
2483#[derive(
2484 Clone,
2485 Debug,
2486 PartialEq,
2487 Eq,
2488 PartialOrd,
2489 Ord,
2490 Serialize,
2491 Deserialize,
2492 Arbitrary
2493)]
2494pub struct AuditLog {
2495 pub key: AuditLogKey,
2496}
2497
2498#[derive(
2499 Clone,
2500 Debug,
2501 PartialEq,
2502 Eq,
2503 PartialOrd,
2504 Ord,
2505 Serialize,
2506 Deserialize,
2507 Arbitrary
2508)]
2509pub struct Cluster {
2510 pub key: ClusterKey,
2511 pub value: ClusterValue,
2512}
2513
2514#[derive(
2515 Clone,
2516 Debug,
2517 PartialEq,
2518 Eq,
2519 PartialOrd,
2520 Ord,
2521 Serialize,
2522 Deserialize,
2523 Arbitrary
2524)]
2525pub struct ClusterReplica {
2526 pub key: ClusterReplicaKey,
2527 pub value: ClusterReplicaValue,
2528}
2529
2530#[derive(
2531 Clone,
2532 Debug,
2533 PartialEq,
2534 Eq,
2535 PartialOrd,
2536 Ord,
2537 Serialize,
2538 Deserialize,
2539 Arbitrary
2540)]
2541pub struct Comment {
2542 pub key: CommentKey,
2543 pub value: CommentValue,
2544}
2545
2546#[derive(
2547 Clone,
2548 Debug,
2549 PartialEq,
2550 Eq,
2551 PartialOrd,
2552 Ord,
2553 Serialize,
2554 Deserialize,
2555 Arbitrary
2556)]
2557pub struct Config {
2558 pub key: ConfigKey,
2559 pub value: ConfigValue,
2560}
2561
2562#[derive(
2563 Clone,
2564 Debug,
2565 PartialEq,
2566 Eq,
2567 PartialOrd,
2568 Ord,
2569 Serialize,
2570 Deserialize,
2571 Arbitrary
2572)]
2573pub struct Database {
2574 pub key: DatabaseKey,
2575 pub value: DatabaseValue,
2576}
2577
2578#[derive(
2579 Clone,
2580 Copy,
2581 Debug,
2582 PartialEq,
2583 Eq,
2584 PartialOrd,
2585 Ord,
2586 Serialize,
2587 Deserialize,
2588 Arbitrary
2589)]
2590pub struct DefaultPrivileges {
2591 pub key: DefaultPrivilegesKey,
2592 pub value: DefaultPrivilegesValue,
2593}
2594
2595#[derive(
2596 Clone,
2597 Copy,
2598 Debug,
2599 PartialEq,
2600 Eq,
2601 PartialOrd,
2602 Ord,
2603 Serialize,
2604 Deserialize,
2605 Arbitrary
2606)]
2607pub struct FenceToken {
2608 pub deploy_generation: u64,
2609 pub epoch: i64,
2610}
2611
2612#[derive(
2613 Clone,
2614 Debug,
2615 PartialEq,
2616 Eq,
2617 PartialOrd,
2618 Ord,
2619 Serialize,
2620 Deserialize,
2621 Arbitrary
2622)]
2623pub struct IdAlloc {
2624 pub key: IdAllocKey,
2625 pub value: IdAllocValue,
2626}
2627
2628#[derive(
2629 Clone,
2630 Debug,
2631 PartialEq,
2632 Eq,
2633 PartialOrd,
2634 Ord,
2635 Serialize,
2636 Deserialize,
2637 Arbitrary
2638)]
2639pub struct ClusterIntrospectionSourceIndex {
2640 pub key: ClusterIntrospectionSourceIndexKey,
2641 pub value: ClusterIntrospectionSourceIndexValue,
2642}
2643
2644#[derive(
2645 Clone,
2646 Debug,
2647 PartialEq,
2648 Eq,
2649 PartialOrd,
2650 Ord,
2651 Serialize,
2652 Deserialize,
2653 Arbitrary
2654)]
2655pub struct Item {
2656 pub key: ItemKey,
2657 pub value: ItemValue,
2658}
2659
2660#[derive(
2661 Clone,
2662 Debug,
2663 PartialEq,
2664 Eq,
2665 PartialOrd,
2666 Ord,
2667 Serialize,
2668 Deserialize,
2669 Arbitrary
2670)]
2671pub struct Role {
2672 pub key: RoleKey,
2673 pub value: RoleValue,
2674}
2675
2676#[derive(
2677 Clone,
2678 Debug,
2679 PartialEq,
2680 Eq,
2681 PartialOrd,
2682 Ord,
2683 Serialize,
2684 Deserialize,
2685 Arbitrary
2686)]
2687pub struct RoleAuth {
2688 pub key: RoleAuthKey,
2689 pub value: RoleAuthValue,
2690}
2691
2692#[derive(
2693 Clone,
2694 Debug,
2695 PartialEq,
2696 Eq,
2697 PartialOrd,
2698 Ord,
2699 Serialize,
2700 Deserialize,
2701 Arbitrary
2702)]
2703pub struct NetworkPolicy {
2704 pub key: NetworkPolicyKey,
2705 pub value: NetworkPolicyValue,
2706}
2707
2708#[derive(
2709 Clone,
2710 Debug,
2711 PartialEq,
2712 Eq,
2713 PartialOrd,
2714 Ord,
2715 Serialize,
2716 Deserialize,
2717 Arbitrary
2718)]
2719pub struct Schema {
2720 pub key: SchemaKey,
2721 pub value: SchemaValue,
2722}
2723
2724#[derive(
2725 Clone,
2726 Debug,
2727 PartialEq,
2728 Eq,
2729 PartialOrd,
2730 Ord,
2731 Serialize,
2732 Deserialize,
2733 Arbitrary
2734)]
2735pub struct Setting {
2736 pub key: SettingKey,
2737 pub value: SettingValue,
2738}
2739
2740#[derive(
2741 Clone,
2742 Debug,
2743 PartialEq,
2744 Eq,
2745 PartialOrd,
2746 Ord,
2747 Serialize,
2748 Deserialize,
2749 Arbitrary
2750)]
2751pub struct ServerConfiguration {
2752 pub key: ServerConfigurationKey,
2753 pub value: ServerConfigurationValue,
2754}
2755
2756#[derive(
2757 Clone,
2758 Debug,
2759 PartialEq,
2760 Eq,
2761 PartialOrd,
2762 Ord,
2763 Serialize,
2764 Deserialize,
2765 Arbitrary
2766)]
2767pub struct SourceReferences {
2768 pub key: SourceReferencesKey,
2769 pub value: SourceReferencesValue,
2770}
2771
2772#[derive(
2773 Clone,
2774 Debug,
2775 PartialEq,
2776 Eq,
2777 PartialOrd,
2778 Ord,
2779 Serialize,
2780 Deserialize,
2781 Arbitrary
2782)]
2783pub struct GidMapping {
2784 pub key: GidMappingKey,
2785 pub value: GidMappingValue,
2786}
2787
2788#[derive(
2789 Clone,
2790 Copy,
2791 Debug,
2792 PartialEq,
2793 Eq,
2794 PartialOrd,
2795 Ord,
2796 Serialize,
2797 Deserialize,
2798 Arbitrary
2799)]
2800pub struct SystemPrivileges {
2801 pub key: SystemPrivilegesKey,
2802 pub value: SystemPrivilegesValue,
2803}
2804
2805#[derive(
2806 Clone,
2807 Debug,
2808 PartialEq,
2809 Eq,
2810 PartialOrd,
2811 Ord,
2812 Serialize,
2813 Deserialize,
2814 Arbitrary
2815)]
2816pub struct StorageCollectionMetadata {
2817 pub key: StorageCollectionMetadataKey,
2818 pub value: StorageCollectionMetadataValue,
2819}
2820
2821#[derive(
2822 Clone,
2823 Debug,
2824 PartialEq,
2825 Eq,
2826 PartialOrd,
2827 Ord,
2828 Serialize,
2829 Deserialize,
2830 Arbitrary
2831)]
2832pub struct UnfinalizedShard {
2833 pub key: UnfinalizedShardKey,
2834}
2835
2836#[derive(
2837 Clone,
2838 Debug,
2839 PartialEq,
2840 Eq,
2841 PartialOrd,
2842 Ord,
2843 Serialize,
2844 Deserialize,
2845 Arbitrary
2846)]
2847pub struct TxnWalShard {
2848 pub value: TxnWalShardValue,
2849}
2850
2851#[derive(
2852 Clone,
2853 Copy,
2854 Debug,
2855 PartialEq,
2856 Eq,
2857 Hash,
2858 PartialOrd,
2859 Ord,
2860 Serialize_repr,
2861 Deserialize_repr,
2862 Arbitrary
2863)]
2864#[repr(u8)]
2865pub enum CatalogItemType {
2866 Unknown = 0,
2867 Table = 1,
2868 Source = 2,
2869 Sink = 3,
2870 View = 4,
2871 MaterializedView = 5,
2872 Index = 6,
2873 Type = 7,
2874 Func = 8,
2875 Secret = 9,
2876 Connection = 10,
2877 ContinualTask = 11,
2878}
2879
2880#[derive(
2881 Clone,
2882 Copy,
2883 Debug,
2884 PartialEq,
2885 Eq,
2886 Hash,
2887 PartialOrd,
2888 Ord,
2889 Serialize_repr,
2890 Deserialize_repr,
2891 Arbitrary
2892)]
2893#[repr(u8)]
2894pub enum ObjectType {
2895 Unknown = 0,
2896 Table = 1,
2897 View = 2,
2898 MaterializedView = 3,
2899 Source = 4,
2900 Sink = 5,
2901 Index = 6,
2902 Type = 7,
2903 Role = 8,
2904 Cluster = 9,
2905 ClusterReplica = 10,
2906 Secret = 11,
2907 Connection = 12,
2908 Database = 13,
2909 Schema = 14,
2910 Func = 15,
2911 ContinualTask = 16,
2912 NetworkPolicy = 17,
2913}