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 enum AutoProvisionSource {
1291 Oidc = 0,
1292 Frontegg = 1,
1293 None = 2,
1294}
1295
1296#[derive(
1297 Clone,
1298 Copy,
1299 Debug,
1300 PartialEq,
1301 Eq,
1302 PartialOrd,
1303 Ord,
1304 Serialize,
1305 Deserialize,
1306 Arbitrary
1307)]
1308pub struct RoleAttributes {
1309 pub inherit: bool,
1310 pub superuser: Option<bool>,
1311 pub login: Option<bool>,
1312 pub auto_provision_source: Option<AutoProvisionSource>,
1313}
1314
1315#[derive(
1316 Clone,
1317 Debug,
1318 PartialEq,
1319 Eq,
1320 PartialOrd,
1321 Ord,
1322 Serialize,
1323 Deserialize,
1324 Arbitrary
1325)]
1326pub struct RoleMembership {
1327 pub map: Vec<RoleMembershipEntry>,
1328}
1329
1330#[derive(
1331 Clone,
1332 Copy,
1333 Debug,
1334 PartialEq,
1335 Eq,
1336 PartialOrd,
1337 Ord,
1338 Serialize,
1339 Deserialize,
1340 Arbitrary
1341)]
1342pub struct RoleMembershipEntry {
1343 pub key: RoleId,
1344 pub value: RoleId,
1345}
1346
1347#[derive(
1348 Clone,
1349 Debug,
1350 PartialEq,
1351 Eq,
1352 PartialOrd,
1353 Ord,
1354 Serialize,
1355 Deserialize,
1356 Arbitrary
1357)]
1358pub struct RoleVars {
1359 pub entries: Vec<RoleVarsEntry>,
1360}
1361
1362#[derive(
1363 Clone,
1364 Debug,
1365 PartialEq,
1366 Eq,
1367 PartialOrd,
1368 Ord,
1369 Serialize,
1370 Deserialize,
1371 Arbitrary
1372)]
1373pub struct RoleVarsEntry {
1374 pub key: String,
1375 pub val: RoleVar,
1376}
1377
1378#[derive(
1379 Clone,
1380 Debug,
1381 PartialEq,
1382 Eq,
1383 PartialOrd,
1384 Ord,
1385 Serialize,
1386 Deserialize,
1387 Arbitrary
1388)]
1389pub enum RoleVar {
1390 Flat(String),
1391 SqlSet(Vec<String>),
1392}
1393
1394#[derive(
1395 Clone,
1396 Debug,
1397 PartialEq,
1398 Eq,
1399 PartialOrd,
1400 Ord,
1401 Serialize,
1402 Deserialize,
1403 Arbitrary
1404)]
1405pub struct NetworkPolicyRule {
1406 pub name: String,
1407 pub address: String,
1408 pub action: NetworkPolicyRuleAction,
1409 pub direction: NetworkPolicyRuleDirection,
1410}
1411
1412#[derive(
1413 Clone,
1414 Copy,
1415 Debug,
1416 PartialEq,
1417 Eq,
1418 PartialOrd,
1419 Ord,
1420 Serialize,
1421 Deserialize,
1422 Arbitrary
1423)]
1424pub enum NetworkPolicyRuleAction {
1425 Allow,
1426}
1427
1428#[derive(
1429 Clone,
1430 Copy,
1431 Debug,
1432 PartialEq,
1433 Eq,
1434 PartialOrd,
1435 Ord,
1436 Serialize,
1437 Deserialize,
1438 Arbitrary
1439)]
1440pub enum NetworkPolicyRuleDirection {
1441 Ingress,
1442}
1443
1444#[derive(
1445 Clone,
1446 Copy,
1447 Debug,
1448 PartialEq,
1449 Eq,
1450 PartialOrd,
1451 Ord,
1452 Serialize,
1453 Deserialize,
1454 Arbitrary
1455)]
1456pub struct AclMode {
1457 pub bitflags: u64,
1458}
1459
1460#[derive(
1461 Clone,
1462 Copy,
1463 Debug,
1464 PartialEq,
1465 Eq,
1466 PartialOrd,
1467 Ord,
1468 Serialize,
1469 Deserialize,
1470 Arbitrary
1471)]
1472pub struct MzAclItem {
1473 pub grantee: RoleId,
1474 pub grantor: RoleId,
1475 pub acl_mode: AclMode,
1476}
1477
1478#[derive(
1479 Clone,
1480 Copy,
1481 Debug,
1482 PartialEq,
1483 Eq,
1484 PartialOrd,
1485 Ord,
1486 Serialize,
1487 Deserialize,
1488 Arbitrary
1489)]
1490pub struct DefaultPrivilegesKey {
1491 pub role_id: RoleId,
1492 pub database_id: Option<DatabaseId>,
1493 pub schema_id: Option<SchemaId>,
1494 pub object_type: ObjectType,
1495 pub grantee: RoleId,
1496}
1497
1498#[derive(
1499 Clone,
1500 Copy,
1501 Debug,
1502 PartialEq,
1503 Eq,
1504 PartialOrd,
1505 Ord,
1506 Serialize,
1507 Deserialize,
1508 Arbitrary
1509)]
1510pub struct DefaultPrivilegesValue {
1511 pub privileges: AclMode,
1512}
1513
1514#[derive(
1515 Clone,
1516 Copy,
1517 Debug,
1518 PartialEq,
1519 Eq,
1520 PartialOrd,
1521 Ord,
1522 Serialize,
1523 Deserialize,
1524 Arbitrary
1525)]
1526pub struct SystemPrivilegesKey {
1527 pub grantee: RoleId,
1528 pub grantor: RoleId,
1529}
1530
1531#[derive(
1532 Clone,
1533 Copy,
1534 Debug,
1535 PartialEq,
1536 Eq,
1537 PartialOrd,
1538 Ord,
1539 Serialize,
1540 Deserialize,
1541 Arbitrary
1542)]
1543pub struct SystemPrivilegesValue {
1544 pub acl_mode: AclMode,
1545}
1546
1547#[derive(
1548 Clone,
1549 Debug,
1550 PartialEq,
1551 Eq,
1552 PartialOrd,
1553 Ord,
1554 Serialize,
1555 Deserialize,
1556 Arbitrary
1557)]
1558pub struct AuditLogEventV1 {
1559 pub id: u64,
1560 pub event_type: audit_log_event_v1::EventType,
1561 pub object_type: audit_log_event_v1::ObjectType,
1562 pub user: Option<StringWrapper>,
1563 pub occurred_at: EpochMillis,
1564 pub details: audit_log_event_v1::Details,
1565}
1566
1567pub mod audit_log_event_v1 {
1568 use super::*;
1569
1570 #[derive(
1571 Clone,
1572 Debug,
1573 PartialEq,
1574 Eq,
1575 PartialOrd,
1576 Ord,
1577 Serialize,
1578 Deserialize,
1579 Arbitrary
1580 )]
1581 pub struct IdFullNameV1 {
1582 pub id: String,
1583 pub name: FullNameV1,
1584 }
1585
1586 #[derive(
1587 Clone,
1588 Debug,
1589 PartialEq,
1590 Eq,
1591 PartialOrd,
1592 Ord,
1593 Serialize,
1594 Deserialize,
1595 Arbitrary
1596 )]
1597 pub struct FullNameV1 {
1598 pub database: String,
1599 pub schema: String,
1600 pub item: String,
1601 }
1602
1603 #[derive(
1604 Clone,
1605 Debug,
1606 PartialEq,
1607 Eq,
1608 PartialOrd,
1609 Ord,
1610 Serialize,
1611 Deserialize,
1612 Arbitrary
1613 )]
1614 pub struct IdNameV1 {
1615 pub id: String,
1616 pub name: String,
1617 }
1618
1619 #[derive(
1620 Clone,
1621 Debug,
1622 PartialEq,
1623 Eq,
1624 PartialOrd,
1625 Ord,
1626 Serialize,
1627 Deserialize,
1628 Arbitrary
1629 )]
1630 pub struct RenameClusterV1 {
1631 pub id: String,
1632 pub old_name: String,
1633 pub new_name: String,
1634 }
1635
1636 #[derive(
1637 Clone,
1638 Debug,
1639 PartialEq,
1640 Eq,
1641 PartialOrd,
1642 Ord,
1643 Serialize,
1644 Deserialize,
1645 Arbitrary
1646 )]
1647 pub struct RenameClusterReplicaV1 {
1648 pub cluster_id: String,
1649 pub replica_id: String,
1650 pub old_name: String,
1651 pub new_name: String,
1652 }
1653
1654 #[derive(
1655 Clone,
1656 Debug,
1657 PartialEq,
1658 Eq,
1659 PartialOrd,
1660 Ord,
1661 Serialize,
1662 Deserialize,
1663 Arbitrary
1664 )]
1665 pub struct RenameItemV1 {
1666 pub id: String,
1667 pub old_name: FullNameV1,
1668 pub new_name: FullNameV1,
1669 }
1670
1671 #[derive(
1672 Clone,
1673 Debug,
1674 PartialEq,
1675 Eq,
1676 PartialOrd,
1677 Ord,
1678 Serialize,
1679 Deserialize,
1680 Arbitrary
1681 )]
1682 pub struct CreateClusterReplicaV1 {
1683 pub cluster_id: String,
1684 pub cluster_name: String,
1685 pub replica_id: Option<StringWrapper>,
1686 pub replica_name: String,
1687 pub logical_size: String,
1688 pub disk: bool,
1689 pub billed_as: Option<String>,
1690 pub internal: bool,
1691 }
1692
1693 #[derive(
1694 Clone,
1695 Debug,
1696 PartialEq,
1697 Eq,
1698 PartialOrd,
1699 Ord,
1700 Serialize,
1701 Deserialize,
1702 Arbitrary
1703 )]
1704 pub struct CreateClusterReplicaV2 {
1705 pub cluster_id: String,
1706 pub cluster_name: String,
1707 pub replica_id: Option<StringWrapper>,
1708 pub replica_name: String,
1709 pub logical_size: String,
1710 pub disk: bool,
1711 pub billed_as: Option<String>,
1712 pub internal: bool,
1713 pub reason: CreateOrDropClusterReplicaReasonV1,
1714 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV1>,
1715 }
1716
1717 #[derive(
1718 Clone,
1719 Debug,
1720 PartialEq,
1721 Eq,
1722 PartialOrd,
1723 Ord,
1724 Serialize,
1725 Deserialize,
1726 Arbitrary
1727 )]
1728 pub struct CreateClusterReplicaV3 {
1729 pub cluster_id: String,
1730 pub cluster_name: String,
1731 pub replica_id: Option<StringWrapper>,
1732 pub replica_name: String,
1733 pub logical_size: String,
1734 pub disk: bool,
1735 pub billed_as: Option<String>,
1736 pub internal: bool,
1737 pub reason: CreateOrDropClusterReplicaReasonV1,
1738 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
1739 }
1740
1741 #[derive(
1742 Clone,
1743 Debug,
1744 PartialEq,
1745 Eq,
1746 PartialOrd,
1747 Ord,
1748 Serialize,
1749 Deserialize,
1750 Arbitrary
1751 )]
1752 pub struct CreateClusterReplicaV4 {
1753 pub cluster_id: String,
1754 pub cluster_name: String,
1755 pub replica_id: Option<StringWrapper>,
1756 pub replica_name: String,
1757 pub logical_size: String,
1758 pub billed_as: Option<String>,
1759 pub internal: bool,
1760 pub reason: CreateOrDropClusterReplicaReasonV1,
1761 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
1762 }
1763
1764 #[derive(
1765 Clone,
1766 Debug,
1767 PartialEq,
1768 Eq,
1769 PartialOrd,
1770 Ord,
1771 Serialize,
1772 Deserialize,
1773 Arbitrary
1774 )]
1775 pub struct DropClusterReplicaV1 {
1776 pub cluster_id: String,
1777 pub cluster_name: String,
1778 pub replica_id: Option<StringWrapper>,
1779 pub replica_name: String,
1780 }
1781
1782 #[derive(
1783 Clone,
1784 Debug,
1785 PartialEq,
1786 Eq,
1787 PartialOrd,
1788 Ord,
1789 Serialize,
1790 Deserialize,
1791 Arbitrary
1792 )]
1793 pub struct DropClusterReplicaV2 {
1794 pub cluster_id: String,
1795 pub cluster_name: String,
1796 pub replica_id: Option<StringWrapper>,
1797 pub replica_name: String,
1798 pub reason: CreateOrDropClusterReplicaReasonV1,
1799 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV1>,
1800 }
1801
1802 #[derive(
1803 Clone,
1804 Debug,
1805 PartialEq,
1806 Eq,
1807 PartialOrd,
1808 Ord,
1809 Serialize,
1810 Deserialize,
1811 Arbitrary
1812 )]
1813 pub struct DropClusterReplicaV3 {
1814 pub cluster_id: String,
1815 pub cluster_name: String,
1816 pub replica_id: Option<StringWrapper>,
1817 pub replica_name: String,
1818 pub reason: CreateOrDropClusterReplicaReasonV1,
1819 pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
1820 }
1821
1822 #[derive(
1823 Clone,
1824 Copy,
1825 Debug,
1826 PartialEq,
1827 Eq,
1828 PartialOrd,
1829 Ord,
1830 Serialize,
1831 Deserialize,
1832 Arbitrary
1833 )]
1834 pub struct CreateOrDropClusterReplicaReasonV1 {
1835 pub reason: CreateOrDropClusterReplicaReasonV1Reason,
1836 }
1837
1838 #[derive(
1839 Clone,
1840 Copy,
1841 Debug,
1842 PartialEq,
1843 Eq,
1844 PartialOrd,
1845 Ord,
1846 Serialize,
1847 Deserialize,
1848 Arbitrary
1849 )]
1850 pub enum CreateOrDropClusterReplicaReasonV1Reason {
1851 Manual(Empty),
1852 Schedule(Empty),
1853 System(Empty),
1854 }
1855
1856 #[derive(
1857 Clone,
1858 Debug,
1859 PartialEq,
1860 Eq,
1861 PartialOrd,
1862 Ord,
1863 Serialize,
1864 Deserialize,
1865 Arbitrary
1866 )]
1867 pub struct SchedulingDecisionsWithReasonsV1 {
1868 pub on_refresh: RefreshDecisionWithReasonV1,
1869 }
1870
1871 #[derive(
1872 Clone,
1873 Debug,
1874 PartialEq,
1875 Eq,
1876 PartialOrd,
1877 Ord,
1878 Serialize,
1879 Deserialize,
1880 Arbitrary
1881 )]
1882 pub struct SchedulingDecisionsWithReasonsV2 {
1883 pub on_refresh: RefreshDecisionWithReasonV2,
1884 }
1885
1886 #[derive(
1887 Clone,
1888 Debug,
1889 PartialEq,
1890 Eq,
1891 PartialOrd,
1892 Ord,
1893 Serialize,
1894 Deserialize,
1895 Arbitrary
1896 )]
1897 pub enum RefreshDecision {
1898 On(Empty),
1899 Off(Empty),
1900 }
1901
1902 #[derive(
1903 Clone,
1904 Debug,
1905 PartialEq,
1906 Eq,
1907 PartialOrd,
1908 Ord,
1909 Serialize,
1910 Deserialize,
1911 Arbitrary
1912 )]
1913 pub struct RefreshDecisionWithReasonV1 {
1914 pub objects_needing_refresh: Vec<String>,
1915 pub rehydration_time_estimate: String,
1916 pub decision: RefreshDecision,
1917 }
1918
1919 #[derive(
1920 Clone,
1921 Debug,
1922 PartialEq,
1923 Eq,
1924 PartialOrd,
1925 Ord,
1926 Serialize,
1927 Deserialize,
1928 Arbitrary
1929 )]
1930 pub struct RefreshDecisionWithReasonV2 {
1931 pub objects_needing_refresh: Vec<String>,
1932 pub objects_needing_compaction: Vec<String>,
1933 pub rehydration_time_estimate: String,
1934 pub decision: RefreshDecision,
1935 }
1936
1937 #[derive(
1938 Clone,
1939 Debug,
1940 PartialEq,
1941 Eq,
1942 PartialOrd,
1943 Ord,
1944 Serialize,
1945 Deserialize,
1946 Arbitrary
1947 )]
1948 pub struct CreateSourceSinkV1 {
1949 pub id: String,
1950 pub name: FullNameV1,
1951 pub size: Option<StringWrapper>,
1952 }
1953
1954 #[derive(
1955 Clone,
1956 Debug,
1957 PartialEq,
1958 Eq,
1959 PartialOrd,
1960 Ord,
1961 Serialize,
1962 Deserialize,
1963 Arbitrary
1964 )]
1965 pub struct CreateSourceSinkV2 {
1966 pub id: String,
1967 pub name: FullNameV1,
1968 pub size: Option<StringWrapper>,
1969 pub external_type: String,
1970 }
1971
1972 #[derive(
1973 Clone,
1974 Debug,
1975 PartialEq,
1976 Eq,
1977 PartialOrd,
1978 Ord,
1979 Serialize,
1980 Deserialize,
1981 Arbitrary
1982 )]
1983 pub struct CreateSourceSinkV3 {
1984 pub id: String,
1985 pub name: FullNameV1,
1986 pub external_type: String,
1987 }
1988
1989 #[derive(
1990 Clone,
1991 Debug,
1992 PartialEq,
1993 Eq,
1994 PartialOrd,
1995 Ord,
1996 Serialize,
1997 Deserialize,
1998 Arbitrary
1999 )]
2000 pub struct CreateSourceSinkV4 {
2001 pub id: String,
2002 pub cluster_id: Option<StringWrapper>,
2003 pub name: FullNameV1,
2004 pub external_type: String,
2005 }
2006
2007 #[derive(
2008 Clone,
2009 Debug,
2010 PartialEq,
2011 Eq,
2012 PartialOrd,
2013 Ord,
2014 Serialize,
2015 Deserialize,
2016 Arbitrary
2017 )]
2018 pub struct CreateIndexV1 {
2019 pub id: String,
2020 pub cluster_id: String,
2021 pub name: FullNameV1,
2022 }
2023
2024 #[derive(
2025 Clone,
2026 Debug,
2027 PartialEq,
2028 Eq,
2029 PartialOrd,
2030 Ord,
2031 Serialize,
2032 Deserialize,
2033 Arbitrary
2034 )]
2035 pub struct CreateMaterializedViewV1 {
2036 pub id: String,
2037 pub cluster_id: String,
2038 pub name: FullNameV1,
2039 pub replacement_target_id: Option<String>,
2040 }
2041
2042 #[derive(
2043 Clone,
2044 Debug,
2045 PartialEq,
2046 Eq,
2047 PartialOrd,
2048 Ord,
2049 Serialize,
2050 Deserialize,
2051 Arbitrary
2052 )]
2053 pub struct AlterApplyReplacementV1 {
2054 pub target: IdFullNameV1,
2055 pub replacement: IdFullNameV1,
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 AlterSourceSinkV1 {
2070 pub id: String,
2071 pub name: FullNameV1,
2072 pub old_size: Option<StringWrapper>,
2073 pub new_size: Option<StringWrapper>,
2074 }
2075
2076 #[derive(
2077 Clone,
2078 Debug,
2079 PartialEq,
2080 Eq,
2081 PartialOrd,
2082 Ord,
2083 Serialize,
2084 Deserialize,
2085 Arbitrary
2086 )]
2087 pub struct AlterSetClusterV1 {
2088 pub id: String,
2089 pub name: FullNameV1,
2090 pub old_cluster_id: String,
2091 pub new_cluster_id: String,
2092 }
2093
2094 #[derive(
2095 Clone,
2096 Debug,
2097 PartialEq,
2098 Eq,
2099 PartialOrd,
2100 Ord,
2101 Serialize,
2102 Deserialize,
2103 Arbitrary
2104 )]
2105 pub struct GrantRoleV1 {
2106 pub role_id: String,
2107 pub member_id: String,
2108 pub grantor_id: String,
2109 }
2110
2111 #[derive(
2112 Clone,
2113 Debug,
2114 PartialEq,
2115 Eq,
2116 PartialOrd,
2117 Ord,
2118 Serialize,
2119 Deserialize,
2120 Arbitrary
2121 )]
2122 pub struct GrantRoleV2 {
2123 pub role_id: String,
2124 pub member_id: String,
2125 pub grantor_id: String,
2126 pub executed_by: String,
2127 }
2128
2129 #[derive(
2130 Clone,
2131 Debug,
2132 PartialEq,
2133 Eq,
2134 PartialOrd,
2135 Ord,
2136 Serialize,
2137 Deserialize,
2138 Arbitrary
2139 )]
2140 pub struct RevokeRoleV1 {
2141 pub role_id: String,
2142 pub member_id: 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 RevokeRoleV2 {
2157 pub role_id: String,
2158 pub member_id: String,
2159 pub grantor_id: String,
2160 pub executed_by: String,
2161 }
2162
2163 #[derive(
2164 Clone,
2165 Debug,
2166 PartialEq,
2167 Eq,
2168 PartialOrd,
2169 Ord,
2170 Serialize,
2171 Deserialize,
2172 Arbitrary
2173 )]
2174 pub struct UpdatePrivilegeV1 {
2175 pub object_id: String,
2176 pub grantee_id: String,
2177 pub grantor_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 AlterDefaultPrivilegeV1 {
2193 pub role_id: String,
2194 pub database_id: Option<StringWrapper>,
2195 pub schema_id: Option<StringWrapper>,
2196 pub grantee_id: String,
2197 pub privileges: String,
2198 }
2199
2200 #[derive(
2201 Clone,
2202 Debug,
2203 PartialEq,
2204 Eq,
2205 PartialOrd,
2206 Ord,
2207 Serialize,
2208 Deserialize,
2209 Arbitrary
2210 )]
2211 pub struct UpdateOwnerV1 {
2212 pub object_id: String,
2213 pub old_owner_id: String,
2214 pub new_owner_id: String,
2215 }
2216
2217 #[derive(
2218 Clone,
2219 Debug,
2220 PartialEq,
2221 Eq,
2222 PartialOrd,
2223 Ord,
2224 Serialize,
2225 Deserialize,
2226 Arbitrary
2227 )]
2228 pub struct SchemaV1 {
2229 pub id: String,
2230 pub name: String,
2231 pub database_name: String,
2232 }
2233
2234 #[derive(
2235 Clone,
2236 Debug,
2237 PartialEq,
2238 Eq,
2239 PartialOrd,
2240 Ord,
2241 Serialize,
2242 Deserialize,
2243 Arbitrary
2244 )]
2245 pub struct SchemaV2 {
2246 pub id: String,
2247 pub name: String,
2248 pub database_name: Option<StringWrapper>,
2249 }
2250
2251 #[derive(
2252 Clone,
2253 Debug,
2254 PartialEq,
2255 Eq,
2256 PartialOrd,
2257 Ord,
2258 Serialize,
2259 Deserialize,
2260 Arbitrary
2261 )]
2262 pub struct RenameSchemaV1 {
2263 pub id: String,
2264 pub database_name: Option<String>,
2265 pub old_name: String,
2266 pub new_name: String,
2267 }
2268
2269 #[derive(
2270 Clone,
2271 Debug,
2272 PartialEq,
2273 Eq,
2274 PartialOrd,
2275 Ord,
2276 Serialize,
2277 Deserialize,
2278 Arbitrary
2279 )]
2280 pub struct UpdateItemV1 {
2281 pub id: String,
2282 pub name: FullNameV1,
2283 }
2284
2285 #[derive(
2286 Clone,
2287 Debug,
2288 PartialEq,
2289 Eq,
2290 PartialOrd,
2291 Ord,
2292 Serialize,
2293 Deserialize,
2294 Arbitrary
2295 )]
2296 pub struct AlterRetainHistoryV1 {
2297 pub id: String,
2298 pub old_history: Option<String>,
2299 pub new_history: Option<String>,
2300 }
2301
2302 #[derive(
2303 Clone,
2304 Debug,
2305 PartialEq,
2306 Eq,
2307 PartialOrd,
2308 Ord,
2309 Serialize,
2310 Deserialize,
2311 Arbitrary
2312 )]
2313 pub struct ToNewIdV1 {
2314 pub id: String,
2315 pub new_id: String,
2316 }
2317
2318 #[derive(
2319 Clone,
2320 Debug,
2321 PartialEq,
2322 Eq,
2323 PartialOrd,
2324 Ord,
2325 Serialize,
2326 Deserialize,
2327 Arbitrary
2328 )]
2329 pub struct FromPreviousIdV1 {
2330 pub id: String,
2331 pub previous_id: String,
2332 }
2333
2334 #[derive(
2335 Clone,
2336 Debug,
2337 PartialEq,
2338 Eq,
2339 PartialOrd,
2340 Ord,
2341 Serialize,
2342 Deserialize,
2343 Arbitrary
2344 )]
2345 pub struct SetV1 {
2346 pub name: String,
2347 pub value: Option<String>,
2348 }
2349
2350 #[derive(
2351 Clone,
2352 Debug,
2353 PartialEq,
2354 Eq,
2355 PartialOrd,
2356 Ord,
2357 Serialize,
2358 Deserialize,
2359 Arbitrary
2360 )]
2361 pub struct RotateKeysV1 {
2362 pub id: String,
2363 pub name: String,
2364 }
2365
2366 #[derive(
2367 Clone,
2368 Debug,
2369 PartialEq,
2370 Eq,
2371 PartialOrd,
2372 Ord,
2373 Serialize,
2374 Deserialize,
2375 Arbitrary
2376 )]
2377 pub struct CreateRoleV1 {
2378 pub id: String,
2379 pub name: String,
2380 pub auto_provision_source: Option<String>,
2381 }
2382
2383 #[derive(
2384 Clone,
2385 Copy,
2386 Debug,
2387 PartialEq,
2388 Eq,
2389 Hash,
2390 PartialOrd,
2391 Ord,
2392 Serialize_repr,
2393 Deserialize_repr,
2394 Arbitrary
2395 )]
2396 #[repr(u8)]
2397 pub enum EventType {
2398 Unknown = 0,
2399 Create = 1,
2400 Drop = 2,
2401 Alter = 3,
2402 Grant = 4,
2403 Revoke = 5,
2404 Comment = 6,
2405 }
2406
2407 #[derive(
2408 Clone,
2409 Copy,
2410 Debug,
2411 PartialEq,
2412 Eq,
2413 Hash,
2414 PartialOrd,
2415 Ord,
2416 Serialize_repr,
2417 Deserialize_repr,
2418 Arbitrary
2419 )]
2420 #[repr(u8)]
2421 pub enum ObjectType {
2422 Unknown = 0,
2423 Cluster = 1,
2424 ClusterReplica = 2,
2425 Connection = 3,
2426 Database = 4,
2427 Func = 5,
2428 Index = 6,
2429 MaterializedView = 7,
2430 Role = 8,
2431 Secret = 9,
2432 Schema = 10,
2433 Sink = 11,
2434 Source = 12,
2435 Table = 13,
2436 Type = 14,
2437 View = 15,
2438 System = 16,
2439 ContinualTask = 17,
2440 NetworkPolicy = 18,
2441 }
2442
2443 #[derive(
2444 Clone,
2445 Debug,
2446 PartialEq,
2447 Eq,
2448 PartialOrd,
2449 Ord,
2450 Serialize,
2451 Deserialize,
2452 Arbitrary
2453 )]
2454 pub enum Details {
2455 CreateClusterReplicaV1(CreateClusterReplicaV1),
2456 CreateClusterReplicaV2(CreateClusterReplicaV2),
2457 CreateClusterReplicaV3(CreateClusterReplicaV3),
2458 CreateClusterReplicaV4(CreateClusterReplicaV4),
2459 DropClusterReplicaV1(DropClusterReplicaV1),
2460 DropClusterReplicaV2(DropClusterReplicaV2),
2461 DropClusterReplicaV3(DropClusterReplicaV3),
2462 CreateSourceSinkV1(CreateSourceSinkV1),
2463 CreateSourceSinkV2(CreateSourceSinkV2),
2464 AlterSourceSinkV1(AlterSourceSinkV1),
2465 AlterSetClusterV1(AlterSetClusterV1),
2466 GrantRoleV1(GrantRoleV1),
2467 GrantRoleV2(GrantRoleV2),
2468 RevokeRoleV1(RevokeRoleV1),
2469 RevokeRoleV2(RevokeRoleV2),
2470 UpdatePrivilegeV1(UpdatePrivilegeV1),
2471 AlterDefaultPrivilegeV1(AlterDefaultPrivilegeV1),
2472 UpdateOwnerV1(UpdateOwnerV1),
2473 IdFullNameV1(IdFullNameV1),
2474 RenameClusterV1(RenameClusterV1),
2475 RenameClusterReplicaV1(RenameClusterReplicaV1),
2476 RenameItemV1(RenameItemV1),
2477 IdNameV1(IdNameV1),
2478 SchemaV1(SchemaV1),
2479 SchemaV2(SchemaV2),
2480 RenameSchemaV1(RenameSchemaV1),
2481 UpdateItemV1(UpdateItemV1),
2482 CreateSourceSinkV3(CreateSourceSinkV3),
2483 AlterRetainHistoryV1(AlterRetainHistoryV1),
2484 ToNewIdV1(ToNewIdV1),
2485 FromPreviousIdV1(FromPreviousIdV1),
2486 SetV1(SetV1),
2487 ResetAllV1(Empty),
2488 RotateKeysV1(RotateKeysV1),
2489 CreateSourceSinkV4(CreateSourceSinkV4),
2490 CreateIndexV1(CreateIndexV1),
2491 CreateMaterializedViewV1(CreateMaterializedViewV1),
2492 AlterApplyReplacementV1(AlterApplyReplacementV1),
2493 CreateRoleV1(CreateRoleV1),
2494 }
2495}
2496
2497#[derive(
2499 Clone,
2500 Debug,
2501 PartialEq,
2502 Eq,
2503 PartialOrd,
2504 Ord,
2505 Serialize,
2506 Deserialize,
2507 Arbitrary
2508)]
2509#[serde(tag = "kind")]
2512pub enum StateUpdateKind {
2513 AuditLog(AuditLog),
2514 Cluster(Cluster),
2515 ClusterIntrospectionSourceIndex(ClusterIntrospectionSourceIndex),
2516 ClusterReplica(ClusterReplica),
2517 Comment(Comment),
2518 Config(Config),
2519 Database(Database),
2520 DefaultPrivileges(DefaultPrivileges),
2521 FenceToken(FenceToken),
2522 GidMapping(GidMapping),
2523 IdAlloc(IdAlloc),
2524 Item(Item),
2525 NetworkPolicy(NetworkPolicy),
2526 Role(Role),
2527 RoleAuth(RoleAuth),
2528 Schema(Schema),
2529 ServerConfiguration(ServerConfiguration),
2530 Setting(Setting),
2531 SourceReferences(SourceReferences),
2532 StorageCollectionMetadata(StorageCollectionMetadata),
2533 SystemPrivileges(SystemPrivileges),
2534 TxnWalShard(TxnWalShard),
2535 UnfinalizedShard(UnfinalizedShard),
2536}
2537
2538#[derive(
2539 Clone,
2540 Debug,
2541 PartialEq,
2542 Eq,
2543 PartialOrd,
2544 Ord,
2545 Serialize,
2546 Deserialize,
2547 Arbitrary
2548)]
2549pub struct AuditLog {
2550 pub key: AuditLogKey,
2551}
2552
2553#[derive(
2554 Clone,
2555 Debug,
2556 PartialEq,
2557 Eq,
2558 PartialOrd,
2559 Ord,
2560 Serialize,
2561 Deserialize,
2562 Arbitrary
2563)]
2564pub struct Cluster {
2565 pub key: ClusterKey,
2566 pub value: ClusterValue,
2567}
2568
2569#[derive(
2570 Clone,
2571 Debug,
2572 PartialEq,
2573 Eq,
2574 PartialOrd,
2575 Ord,
2576 Serialize,
2577 Deserialize,
2578 Arbitrary
2579)]
2580pub struct ClusterReplica {
2581 pub key: ClusterReplicaKey,
2582 pub value: ClusterReplicaValue,
2583}
2584
2585#[derive(
2586 Clone,
2587 Debug,
2588 PartialEq,
2589 Eq,
2590 PartialOrd,
2591 Ord,
2592 Serialize,
2593 Deserialize,
2594 Arbitrary
2595)]
2596pub struct Comment {
2597 pub key: CommentKey,
2598 pub value: CommentValue,
2599}
2600
2601#[derive(
2602 Clone,
2603 Debug,
2604 PartialEq,
2605 Eq,
2606 PartialOrd,
2607 Ord,
2608 Serialize,
2609 Deserialize,
2610 Arbitrary
2611)]
2612pub struct Config {
2613 pub key: ConfigKey,
2614 pub value: ConfigValue,
2615}
2616
2617#[derive(
2618 Clone,
2619 Debug,
2620 PartialEq,
2621 Eq,
2622 PartialOrd,
2623 Ord,
2624 Serialize,
2625 Deserialize,
2626 Arbitrary
2627)]
2628pub struct Database {
2629 pub key: DatabaseKey,
2630 pub value: DatabaseValue,
2631}
2632
2633#[derive(
2634 Clone,
2635 Copy,
2636 Debug,
2637 PartialEq,
2638 Eq,
2639 PartialOrd,
2640 Ord,
2641 Serialize,
2642 Deserialize,
2643 Arbitrary
2644)]
2645pub struct DefaultPrivileges {
2646 pub key: DefaultPrivilegesKey,
2647 pub value: DefaultPrivilegesValue,
2648}
2649
2650#[derive(
2651 Clone,
2652 Copy,
2653 Debug,
2654 PartialEq,
2655 Eq,
2656 PartialOrd,
2657 Ord,
2658 Serialize,
2659 Deserialize,
2660 Arbitrary
2661)]
2662pub struct FenceToken {
2663 pub deploy_generation: u64,
2664 pub epoch: i64,
2665}
2666
2667#[derive(
2668 Clone,
2669 Debug,
2670 PartialEq,
2671 Eq,
2672 PartialOrd,
2673 Ord,
2674 Serialize,
2675 Deserialize,
2676 Arbitrary
2677)]
2678pub struct IdAlloc {
2679 pub key: IdAllocKey,
2680 pub value: IdAllocValue,
2681}
2682
2683#[derive(
2684 Clone,
2685 Debug,
2686 PartialEq,
2687 Eq,
2688 PartialOrd,
2689 Ord,
2690 Serialize,
2691 Deserialize,
2692 Arbitrary
2693)]
2694pub struct ClusterIntrospectionSourceIndex {
2695 pub key: ClusterIntrospectionSourceIndexKey,
2696 pub value: ClusterIntrospectionSourceIndexValue,
2697}
2698
2699#[derive(
2700 Clone,
2701 Debug,
2702 PartialEq,
2703 Eq,
2704 PartialOrd,
2705 Ord,
2706 Serialize,
2707 Deserialize,
2708 Arbitrary
2709)]
2710pub struct Item {
2711 pub key: ItemKey,
2712 pub value: ItemValue,
2713}
2714
2715#[derive(
2716 Clone,
2717 Debug,
2718 PartialEq,
2719 Eq,
2720 PartialOrd,
2721 Ord,
2722 Serialize,
2723 Deserialize,
2724 Arbitrary
2725)]
2726pub struct Role {
2727 pub key: RoleKey,
2728 pub value: RoleValue,
2729}
2730
2731#[derive(
2732 Clone,
2733 Debug,
2734 PartialEq,
2735 Eq,
2736 PartialOrd,
2737 Ord,
2738 Serialize,
2739 Deserialize,
2740 Arbitrary
2741)]
2742pub struct RoleAuth {
2743 pub key: RoleAuthKey,
2744 pub value: RoleAuthValue,
2745}
2746
2747#[derive(
2748 Clone,
2749 Debug,
2750 PartialEq,
2751 Eq,
2752 PartialOrd,
2753 Ord,
2754 Serialize,
2755 Deserialize,
2756 Arbitrary
2757)]
2758pub struct NetworkPolicy {
2759 pub key: NetworkPolicyKey,
2760 pub value: NetworkPolicyValue,
2761}
2762
2763#[derive(
2764 Clone,
2765 Debug,
2766 PartialEq,
2767 Eq,
2768 PartialOrd,
2769 Ord,
2770 Serialize,
2771 Deserialize,
2772 Arbitrary
2773)]
2774pub struct Schema {
2775 pub key: SchemaKey,
2776 pub value: SchemaValue,
2777}
2778
2779#[derive(
2780 Clone,
2781 Debug,
2782 PartialEq,
2783 Eq,
2784 PartialOrd,
2785 Ord,
2786 Serialize,
2787 Deserialize,
2788 Arbitrary
2789)]
2790pub struct Setting {
2791 pub key: SettingKey,
2792 pub value: SettingValue,
2793}
2794
2795#[derive(
2796 Clone,
2797 Debug,
2798 PartialEq,
2799 Eq,
2800 PartialOrd,
2801 Ord,
2802 Serialize,
2803 Deserialize,
2804 Arbitrary
2805)]
2806pub struct ServerConfiguration {
2807 pub key: ServerConfigurationKey,
2808 pub value: ServerConfigurationValue,
2809}
2810
2811#[derive(
2812 Clone,
2813 Debug,
2814 PartialEq,
2815 Eq,
2816 PartialOrd,
2817 Ord,
2818 Serialize,
2819 Deserialize,
2820 Arbitrary
2821)]
2822pub struct SourceReferences {
2823 pub key: SourceReferencesKey,
2824 pub value: SourceReferencesValue,
2825}
2826
2827#[derive(
2828 Clone,
2829 Debug,
2830 PartialEq,
2831 Eq,
2832 PartialOrd,
2833 Ord,
2834 Serialize,
2835 Deserialize,
2836 Arbitrary
2837)]
2838pub struct GidMapping {
2839 pub key: GidMappingKey,
2840 pub value: GidMappingValue,
2841}
2842
2843#[derive(
2844 Clone,
2845 Copy,
2846 Debug,
2847 PartialEq,
2848 Eq,
2849 PartialOrd,
2850 Ord,
2851 Serialize,
2852 Deserialize,
2853 Arbitrary
2854)]
2855pub struct SystemPrivileges {
2856 pub key: SystemPrivilegesKey,
2857 pub value: SystemPrivilegesValue,
2858}
2859
2860#[derive(
2861 Clone,
2862 Debug,
2863 PartialEq,
2864 Eq,
2865 PartialOrd,
2866 Ord,
2867 Serialize,
2868 Deserialize,
2869 Arbitrary
2870)]
2871pub struct StorageCollectionMetadata {
2872 pub key: StorageCollectionMetadataKey,
2873 pub value: StorageCollectionMetadataValue,
2874}
2875
2876#[derive(
2877 Clone,
2878 Debug,
2879 PartialEq,
2880 Eq,
2881 PartialOrd,
2882 Ord,
2883 Serialize,
2884 Deserialize,
2885 Arbitrary
2886)]
2887pub struct UnfinalizedShard {
2888 pub key: UnfinalizedShardKey,
2889}
2890
2891#[derive(
2892 Clone,
2893 Debug,
2894 PartialEq,
2895 Eq,
2896 PartialOrd,
2897 Ord,
2898 Serialize,
2899 Deserialize,
2900 Arbitrary
2901)]
2902pub struct TxnWalShard {
2903 pub value: TxnWalShardValue,
2904}
2905
2906#[derive(
2907 Clone,
2908 Copy,
2909 Debug,
2910 PartialEq,
2911 Eq,
2912 Hash,
2913 PartialOrd,
2914 Ord,
2915 Serialize_repr,
2916 Deserialize_repr,
2917 Arbitrary
2918)]
2919#[repr(u8)]
2920pub enum CatalogItemType {
2921 Unknown = 0,
2922 Table = 1,
2923 Source = 2,
2924 Sink = 3,
2925 View = 4,
2926 MaterializedView = 5,
2927 Index = 6,
2928 Type = 7,
2929 Func = 8,
2930 Secret = 9,
2931 Connection = 10,
2932 ContinualTask = 11,
2933}
2934
2935#[derive(
2936 Clone,
2937 Copy,
2938 Debug,
2939 PartialEq,
2940 Eq,
2941 Hash,
2942 PartialOrd,
2943 Ord,
2944 Serialize_repr,
2945 Deserialize_repr,
2946 Arbitrary
2947)]
2948#[repr(u8)]
2949pub enum ObjectType {
2950 Unknown = 0,
2951 Table = 1,
2952 View = 2,
2953 MaterializedView = 3,
2954 Source = 4,
2955 Sink = 5,
2956 Index = 6,
2957 Type = 7,
2958 Role = 8,
2959 Cluster = 9,
2960 ClusterReplica = 10,
2961 Secret = 11,
2962 Connection = 12,
2963 Database = 13,
2964 Schema = 14,
2965 Func = 15,
2966 ContinualTask = 16,
2967 NetworkPolicy = 17,
2968}