mz_catalog_protos/
objects_v76.rs

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

mz_catalog_protos/
objects_v76.rs
