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 pub replacement_target_id: Option<String>,
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 AlterApplyReplacementV1 {
2035 pub target: IdFullNameV1,
2036 pub replacement: IdFullNameV1,
2037 }
2038
2039 #[derive(
2040 Clone,
2041 Debug,
2042 PartialEq,
2043 Eq,
2044 PartialOrd,
2045 Ord,
2046 Serialize,
2047 Deserialize,
2048 Arbitrary
2049 )]
2050 pub struct AlterSourceSinkV1 {
2051 pub id: String,
2052 pub name: FullNameV1,
2053 pub old_size: Option<StringWrapper>,
2054 pub new_size: Option<StringWrapper>,
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 AlterSetClusterV1 {
2069 pub id: String,
2070 pub name: FullNameV1,
2071 pub old_cluster_id: String,
2072 pub new_cluster_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 GrantRoleV1 {
2087 pub role_id: String,
2088 pub member_id: String,
2089 pub grantor_id: String,
2090 }
2091
2092 #[derive(
2093 Clone,
2094 Debug,
2095 PartialEq,
2096 Eq,
2097 PartialOrd,
2098 Ord,
2099 Serialize,
2100 Deserialize,
2101 Arbitrary
2102 )]
2103 pub struct GrantRoleV2 {
2104 pub role_id: String,
2105 pub member_id: String,
2106 pub grantor_id: String,
2107 pub executed_by: 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 RevokeRoleV1 {
2122 pub role_id: String,
2123 pub member_id: String,
2124 }
2125
2126 #[derive(
2127 Clone,
2128 Debug,
2129 PartialEq,
2130 Eq,
2131 PartialOrd,
2132 Ord,
2133 Serialize,
2134 Deserialize,
2135 Arbitrary
2136 )]
2137 pub struct RevokeRoleV2 {
2138 pub role_id: String,
2139 pub member_id: String,
2140 pub grantor_id: String,
2141 pub executed_by: 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 UpdatePrivilegeV1 {
2156 pub object_id: String,
2157 pub grantee_id: String,
2158 pub grantor_id: String,
2159 pub privileges: 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 AlterDefaultPrivilegeV1 {
2174 pub role_id: String,
2175 pub database_id: Option<StringWrapper>,
2176 pub schema_id: Option<StringWrapper>,
2177 pub grantee_id: String,
2178 pub privileges: 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 UpdateOwnerV1 {
2193 pub object_id: String,
2194 pub old_owner_id: String,
2195 pub new_owner_id: 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 SchemaV1 {
2210 pub id: String,
2211 pub name: String,
2212 pub database_name: String,
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 SchemaV2 {
2227 pub id: String,
2228 pub name: String,
2229 pub database_name: Option<StringWrapper>,
2230 }
2231
2232 #[derive(
2233 Clone,
2234 Debug,
2235 PartialEq,
2236 Eq,
2237 PartialOrd,
2238 Ord,
2239 Serialize,
2240 Deserialize,
2241 Arbitrary
2242 )]
2243 pub struct RenameSchemaV1 {
2244 pub id: String,
2245 pub database_name: Option<String>,
2246 pub old_name: String,
2247 pub new_name: String,
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 UpdateItemV1 {
2262 pub id: String,
2263 pub name: FullNameV1,
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 AlterRetainHistoryV1 {
2278 pub id: String,
2279 pub old_history: Option<String>,
2280 pub new_history: Option<String>,
2281 }
2282
2283 #[derive(
2284 Clone,
2285 Debug,
2286 PartialEq,
2287 Eq,
2288 PartialOrd,
2289 Ord,
2290 Serialize,
2291 Deserialize,
2292 Arbitrary
2293 )]
2294 pub struct ToNewIdV1 {
2295 pub id: String,
2296 pub new_id: String,
2297 }
2298
2299 #[derive(
2300 Clone,
2301 Debug,
2302 PartialEq,
2303 Eq,
2304 PartialOrd,
2305 Ord,
2306 Serialize,
2307 Deserialize,
2308 Arbitrary
2309 )]
2310 pub struct FromPreviousIdV1 {
2311 pub id: String,
2312 pub previous_id: String,
2313 }
2314
2315 #[derive(
2316 Clone,
2317 Debug,
2318 PartialEq,
2319 Eq,
2320 PartialOrd,
2321 Ord,
2322 Serialize,
2323 Deserialize,
2324 Arbitrary
2325 )]
2326 pub struct SetV1 {
2327 pub name: String,
2328 pub value: Option<String>,
2329 }
2330
2331 #[derive(
2332 Clone,
2333 Debug,
2334 PartialEq,
2335 Eq,
2336 PartialOrd,
2337 Ord,
2338 Serialize,
2339 Deserialize,
2340 Arbitrary
2341 )]
2342 pub struct RotateKeysV1 {
2343 pub id: String,
2344 pub name: String,
2345 }
2346
2347 #[derive(
2348 Clone,
2349 Copy,
2350 Debug,
2351 PartialEq,
2352 Eq,
2353 Hash,
2354 PartialOrd,
2355 Ord,
2356 Serialize_repr,
2357 Deserialize_repr,
2358 Arbitrary
2359 )]
2360 #[repr(u8)]
2361 pub enum EventType {
2362 Unknown = 0,
2363 Create = 1,
2364 Drop = 2,
2365 Alter = 3,
2366 Grant = 4,
2367 Revoke = 5,
2368 Comment = 6,
2369 }
2370
2371 #[derive(
2372 Clone,
2373 Copy,
2374 Debug,
2375 PartialEq,
2376 Eq,
2377 Hash,
2378 PartialOrd,
2379 Ord,
2380 Serialize_repr,
2381 Deserialize_repr,
2382 Arbitrary
2383 )]
2384 #[repr(u8)]
2385 pub enum ObjectType {
2386 Unknown = 0,
2387 Cluster = 1,
2388 ClusterReplica = 2,
2389 Connection = 3,
2390 Database = 4,
2391 Func = 5,
2392 Index = 6,
2393 MaterializedView = 7,
2394 Role = 8,
2395 Secret = 9,
2396 Schema = 10,
2397 Sink = 11,
2398 Source = 12,
2399 Table = 13,
2400 Type = 14,
2401 View = 15,
2402 System = 16,
2403 ContinualTask = 17,
2404 NetworkPolicy = 18,
2405 }
2406
2407 #[derive(
2408 Clone,
2409 Debug,
2410 PartialEq,
2411 Eq,
2412 PartialOrd,
2413 Ord,
2414 Serialize,
2415 Deserialize,
2416 Arbitrary
2417 )]
2418 pub enum Details {
2419 CreateClusterReplicaV1(CreateClusterReplicaV1),
2420 CreateClusterReplicaV2(CreateClusterReplicaV2),
2421 CreateClusterReplicaV3(CreateClusterReplicaV3),
2422 CreateClusterReplicaV4(CreateClusterReplicaV4),
2423 DropClusterReplicaV1(DropClusterReplicaV1),
2424 DropClusterReplicaV2(DropClusterReplicaV2),
2425 DropClusterReplicaV3(DropClusterReplicaV3),
2426 CreateSourceSinkV1(CreateSourceSinkV1),
2427 CreateSourceSinkV2(CreateSourceSinkV2),
2428 AlterSourceSinkV1(AlterSourceSinkV1),
2429 AlterSetClusterV1(AlterSetClusterV1),
2430 GrantRoleV1(GrantRoleV1),
2431 GrantRoleV2(GrantRoleV2),
2432 RevokeRoleV1(RevokeRoleV1),
2433 RevokeRoleV2(RevokeRoleV2),
2434 UpdatePrivilegeV1(UpdatePrivilegeV1),
2435 AlterDefaultPrivilegeV1(AlterDefaultPrivilegeV1),
2436 UpdateOwnerV1(UpdateOwnerV1),
2437 IdFullNameV1(IdFullNameV1),
2438 RenameClusterV1(RenameClusterV1),
2439 RenameClusterReplicaV1(RenameClusterReplicaV1),
2440 RenameItemV1(RenameItemV1),
2441 IdNameV1(IdNameV1),
2442 SchemaV1(SchemaV1),
2443 SchemaV2(SchemaV2),
2444 RenameSchemaV1(RenameSchemaV1),
2445 UpdateItemV1(UpdateItemV1),
2446 CreateSourceSinkV3(CreateSourceSinkV3),
2447 AlterRetainHistoryV1(AlterRetainHistoryV1),
2448 ToNewIdV1(ToNewIdV1),
2449 FromPreviousIdV1(FromPreviousIdV1),
2450 SetV1(SetV1),
2451 ResetAllV1(Empty),
2452 RotateKeysV1(RotateKeysV1),
2453 CreateSourceSinkV4(CreateSourceSinkV4),
2454 CreateIndexV1(CreateIndexV1),
2455 CreateMaterializedViewV1(CreateMaterializedViewV1),
2456 AlterApplyReplacementV1(AlterApplyReplacementV1),
2457 }
2458}
2459
2460#[derive(
2462 Clone,
2463 Debug,
2464 PartialEq,
2465 Eq,
2466 PartialOrd,
2467 Ord,
2468 Serialize,
2469 Deserialize,
2470 Arbitrary
2471)]
2472#[serde(tag = "kind")]
2475pub enum StateUpdateKind {
2476 AuditLog(AuditLog),
2477 Cluster(Cluster),
2478 ClusterIntrospectionSourceIndex(ClusterIntrospectionSourceIndex),
2479 ClusterReplica(ClusterReplica),
2480 Comment(Comment),
2481 Config(Config),
2482 Database(Database),
2483 DefaultPrivileges(DefaultPrivileges),
2484 FenceToken(FenceToken),
2485 GidMapping(GidMapping),
2486 IdAlloc(IdAlloc),
2487 Item(Item),
2488 NetworkPolicy(NetworkPolicy),
2489 Role(Role),
2490 RoleAuth(RoleAuth),
2491 Schema(Schema),
2492 ServerConfiguration(ServerConfiguration),
2493 Setting(Setting),
2494 SourceReferences(SourceReferences),
2495 StorageCollectionMetadata(StorageCollectionMetadata),
2496 SystemPrivileges(SystemPrivileges),
2497 TxnWalShard(TxnWalShard),
2498 UnfinalizedShard(UnfinalizedShard),
2499}
2500
2501#[derive(
2502 Clone,
2503 Debug,
2504 PartialEq,
2505 Eq,
2506 PartialOrd,
2507 Ord,
2508 Serialize,
2509 Deserialize,
2510 Arbitrary
2511)]
2512pub struct AuditLog {
2513 pub key: AuditLogKey,
2514}
2515
2516#[derive(
2517 Clone,
2518 Debug,
2519 PartialEq,
2520 Eq,
2521 PartialOrd,
2522 Ord,
2523 Serialize,
2524 Deserialize,
2525 Arbitrary
2526)]
2527pub struct Cluster {
2528 pub key: ClusterKey,
2529 pub value: ClusterValue,
2530}
2531
2532#[derive(
2533 Clone,
2534 Debug,
2535 PartialEq,
2536 Eq,
2537 PartialOrd,
2538 Ord,
2539 Serialize,
2540 Deserialize,
2541 Arbitrary
2542)]
2543pub struct ClusterReplica {
2544 pub key: ClusterReplicaKey,
2545 pub value: ClusterReplicaValue,
2546}
2547
2548#[derive(
2549 Clone,
2550 Debug,
2551 PartialEq,
2552 Eq,
2553 PartialOrd,
2554 Ord,
2555 Serialize,
2556 Deserialize,
2557 Arbitrary
2558)]
2559pub struct Comment {
2560 pub key: CommentKey,
2561 pub value: CommentValue,
2562}
2563
2564#[derive(
2565 Clone,
2566 Debug,
2567 PartialEq,
2568 Eq,
2569 PartialOrd,
2570 Ord,
2571 Serialize,
2572 Deserialize,
2573 Arbitrary
2574)]
2575pub struct Config {
2576 pub key: ConfigKey,
2577 pub value: ConfigValue,
2578}
2579
2580#[derive(
2581 Clone,
2582 Debug,
2583 PartialEq,
2584 Eq,
2585 PartialOrd,
2586 Ord,
2587 Serialize,
2588 Deserialize,
2589 Arbitrary
2590)]
2591pub struct Database {
2592 pub key: DatabaseKey,
2593 pub value: DatabaseValue,
2594}
2595
2596#[derive(
2597 Clone,
2598 Copy,
2599 Debug,
2600 PartialEq,
2601 Eq,
2602 PartialOrd,
2603 Ord,
2604 Serialize,
2605 Deserialize,
2606 Arbitrary
2607)]
2608pub struct DefaultPrivileges {
2609 pub key: DefaultPrivilegesKey,
2610 pub value: DefaultPrivilegesValue,
2611}
2612
2613#[derive(
2614 Clone,
2615 Copy,
2616 Debug,
2617 PartialEq,
2618 Eq,
2619 PartialOrd,
2620 Ord,
2621 Serialize,
2622 Deserialize,
2623 Arbitrary
2624)]
2625pub struct FenceToken {
2626 pub deploy_generation: u64,
2627 pub epoch: i64,
2628}
2629
2630#[derive(
2631 Clone,
2632 Debug,
2633 PartialEq,
2634 Eq,
2635 PartialOrd,
2636 Ord,
2637 Serialize,
2638 Deserialize,
2639 Arbitrary
2640)]
2641pub struct IdAlloc {
2642 pub key: IdAllocKey,
2643 pub value: IdAllocValue,
2644}
2645
2646#[derive(
2647 Clone,
2648 Debug,
2649 PartialEq,
2650 Eq,
2651 PartialOrd,
2652 Ord,
2653 Serialize,
2654 Deserialize,
2655 Arbitrary
2656)]
2657pub struct ClusterIntrospectionSourceIndex {
2658 pub key: ClusterIntrospectionSourceIndexKey,
2659 pub value: ClusterIntrospectionSourceIndexValue,
2660}
2661
2662#[derive(
2663 Clone,
2664 Debug,
2665 PartialEq,
2666 Eq,
2667 PartialOrd,
2668 Ord,
2669 Serialize,
2670 Deserialize,
2671 Arbitrary
2672)]
2673pub struct Item {
2674 pub key: ItemKey,
2675 pub value: ItemValue,
2676}
2677
2678#[derive(
2679 Clone,
2680 Debug,
2681 PartialEq,
2682 Eq,
2683 PartialOrd,
2684 Ord,
2685 Serialize,
2686 Deserialize,
2687 Arbitrary
2688)]
2689pub struct Role {
2690 pub key: RoleKey,
2691 pub value: RoleValue,
2692}
2693
2694#[derive(
2695 Clone,
2696 Debug,
2697 PartialEq,
2698 Eq,
2699 PartialOrd,
2700 Ord,
2701 Serialize,
2702 Deserialize,
2703 Arbitrary
2704)]
2705pub struct RoleAuth {
2706 pub key: RoleAuthKey,
2707 pub value: RoleAuthValue,
2708}
2709
2710#[derive(
2711 Clone,
2712 Debug,
2713 PartialEq,
2714 Eq,
2715 PartialOrd,
2716 Ord,
2717 Serialize,
2718 Deserialize,
2719 Arbitrary
2720)]
2721pub struct NetworkPolicy {
2722 pub key: NetworkPolicyKey,
2723 pub value: NetworkPolicyValue,
2724}
2725
2726#[derive(
2727 Clone,
2728 Debug,
2729 PartialEq,
2730 Eq,
2731 PartialOrd,
2732 Ord,
2733 Serialize,
2734 Deserialize,
2735 Arbitrary
2736)]
2737pub struct Schema {
2738 pub key: SchemaKey,
2739 pub value: SchemaValue,
2740}
2741
2742#[derive(
2743 Clone,
2744 Debug,
2745 PartialEq,
2746 Eq,
2747 PartialOrd,
2748 Ord,
2749 Serialize,
2750 Deserialize,
2751 Arbitrary
2752)]
2753pub struct Setting {
2754 pub key: SettingKey,
2755 pub value: SettingValue,
2756}
2757
2758#[derive(
2759 Clone,
2760 Debug,
2761 PartialEq,
2762 Eq,
2763 PartialOrd,
2764 Ord,
2765 Serialize,
2766 Deserialize,
2767 Arbitrary
2768)]
2769pub struct ServerConfiguration {
2770 pub key: ServerConfigurationKey,
2771 pub value: ServerConfigurationValue,
2772}
2773
2774#[derive(
2775 Clone,
2776 Debug,
2777 PartialEq,
2778 Eq,
2779 PartialOrd,
2780 Ord,
2781 Serialize,
2782 Deserialize,
2783 Arbitrary
2784)]
2785pub struct SourceReferences {
2786 pub key: SourceReferencesKey,
2787 pub value: SourceReferencesValue,
2788}
2789
2790#[derive(
2791 Clone,
2792 Debug,
2793 PartialEq,
2794 Eq,
2795 PartialOrd,
2796 Ord,
2797 Serialize,
2798 Deserialize,
2799 Arbitrary
2800)]
2801pub struct GidMapping {
2802 pub key: GidMappingKey,
2803 pub value: GidMappingValue,
2804}
2805
2806#[derive(
2807 Clone,
2808 Copy,
2809 Debug,
2810 PartialEq,
2811 Eq,
2812 PartialOrd,
2813 Ord,
2814 Serialize,
2815 Deserialize,
2816 Arbitrary
2817)]
2818pub struct SystemPrivileges {
2819 pub key: SystemPrivilegesKey,
2820 pub value: SystemPrivilegesValue,
2821}
2822
2823#[derive(
2824 Clone,
2825 Debug,
2826 PartialEq,
2827 Eq,
2828 PartialOrd,
2829 Ord,
2830 Serialize,
2831 Deserialize,
2832 Arbitrary
2833)]
2834pub struct StorageCollectionMetadata {
2835 pub key: StorageCollectionMetadataKey,
2836 pub value: StorageCollectionMetadataValue,
2837}
2838
2839#[derive(
2840 Clone,
2841 Debug,
2842 PartialEq,
2843 Eq,
2844 PartialOrd,
2845 Ord,
2846 Serialize,
2847 Deserialize,
2848 Arbitrary
2849)]
2850pub struct UnfinalizedShard {
2851 pub key: UnfinalizedShardKey,
2852}
2853
2854#[derive(
2855 Clone,
2856 Debug,
2857 PartialEq,
2858 Eq,
2859 PartialOrd,
2860 Ord,
2861 Serialize,
2862 Deserialize,
2863 Arbitrary
2864)]
2865pub struct TxnWalShard {
2866 pub value: TxnWalShardValue,
2867}
2868
2869#[derive(
2870 Clone,
2871 Copy,
2872 Debug,
2873 PartialEq,
2874 Eq,
2875 Hash,
2876 PartialOrd,
2877 Ord,
2878 Serialize_repr,
2879 Deserialize_repr,
2880 Arbitrary
2881)]
2882#[repr(u8)]
2883pub enum CatalogItemType {
2884 Unknown = 0,
2885 Table = 1,
2886 Source = 2,
2887 Sink = 3,
2888 View = 4,
2889 MaterializedView = 5,
2890 Index = 6,
2891 Type = 7,
2892 Func = 8,
2893 Secret = 9,
2894 Connection = 10,
2895 ContinualTask = 11,
2896}
2897
2898#[derive(
2899 Clone,
2900 Copy,
2901 Debug,
2902 PartialEq,
2903 Eq,
2904 Hash,
2905 PartialOrd,
2906 Ord,
2907 Serialize_repr,
2908 Deserialize_repr,
2909 Arbitrary
2910)]
2911#[repr(u8)]
2912pub enum ObjectType {
2913 Unknown = 0,
2914 Table = 1,
2915 View = 2,
2916 MaterializedView = 3,
2917 Source = 4,
2918 Sink = 5,
2919 Index = 6,
2920 Type = 7,
2921 Role = 8,
2922 Cluster = 9,
2923 ClusterReplica = 10,
2924 Secret = 11,
2925 Connection = 12,
2926 Database = 13,
2927 Schema = 14,
2928 Func = 15,
2929 ContinualTask = 16,
2930 NetworkPolicy = 17,
2931}