mz_catalog_protos/
objects_v75.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 disk: bool,
1478        pub optimizer_feature_overrides: Vec<OptimizerFeatureOverride>,
1479        pub schedule: Option<ClusterSchedule>,
1480    }
1481
1482    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
1483    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1484    pub enum Variant {
1485        Unmanaged(Empty),
1486        Managed(ManagedCluster),
1487    }
1488}
1489
1490#[derive(
1491    Clone,
1492    Debug,
1493    Default,
1494    PartialEq,
1495    Eq,
1496    PartialOrd,
1497    Ord,
1498    Serialize,
1499    Deserialize
1500)]
1501#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1502pub struct ReplicaConfig {
1503    pub logging: Option<ReplicaLogging>,
1504    pub location: Option<replica_config::Location>,
1505}
1506
1507pub mod replica_config {
1508    use super::*;
1509
1510    #[derive(
1511        Clone,
1512        Debug,
1513        Default,
1514        PartialEq,
1515        Eq,
1516        PartialOrd,
1517        Ord,
1518        Serialize,
1519        Deserialize
1520    )]
1521    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1522    pub struct UnmanagedLocation {
1523        pub storagectl_addrs: Vec<String>,
1524        pub computectl_addrs: Vec<String>,
1525    }
1526
1527    #[derive(
1528        Clone,
1529        Debug,
1530        Default,
1531        PartialEq,
1532        Eq,
1533        PartialOrd,
1534        Ord,
1535        Serialize,
1536        Deserialize
1537    )]
1538    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1539    pub struct ManagedLocation {
1540        pub size: String,
1541        pub availability_zone: Option<String>,
1542        pub disk: bool,
1543        pub internal: bool,
1544        pub billed_as: Option<String>,
1545        pub pending: bool,
1546    }
1547
1548    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
1549    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1550    pub enum Location {
1551        Unmanaged(UnmanagedLocation),
1552        Managed(ManagedLocation),
1553    }
1554}
1555
1556#[derive(
1557    Clone,
1558    Copy,
1559    Debug,
1560    Default,
1561    PartialEq,
1562    Eq,
1563    PartialOrd,
1564    Ord,
1565    Serialize,
1566    Deserialize
1567)]
1568#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1569pub struct RoleId {
1570    pub value: Option<role_id::Value>,
1571}
1572
1573pub mod role_id {
1574    use super::*;
1575
1576    #[derive(
1577        Clone,
1578        Copy,
1579        Debug,
1580        PartialEq,
1581        Eq,
1582        PartialOrd,
1583        Ord,
1584        Serialize,
1585        Deserialize
1586    )]
1587    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1588    pub enum Value {
1589        System(u64),
1590        User(u64),
1591        Public(Empty),
1592        Predefined(u64),
1593    }
1594}
1595
1596#[derive(
1597    Clone,
1598    Copy,
1599    Debug,
1600    Default,
1601    PartialEq,
1602    Eq,
1603    PartialOrd,
1604    Ord,
1605    Serialize,
1606    Deserialize
1607)]
1608#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1609pub struct RoleAttributes {
1610    pub inherit: bool,
1611    pub superuser: Option<bool>,
1612    pub login: Option<bool>,
1613}
1614
1615#[derive(
1616    Clone,
1617    Debug,
1618    Default,
1619    PartialEq,
1620    Eq,
1621    PartialOrd,
1622    Ord,
1623    Serialize,
1624    Deserialize
1625)]
1626#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1627pub struct RoleMembership {
1628    pub map: Vec<role_membership::Entry>,
1629}
1630
1631pub mod role_membership {
1632    use super::*;
1633
1634    #[derive(
1635        Clone,
1636        Copy,
1637        Debug,
1638        Default,
1639        PartialEq,
1640        Eq,
1641        PartialOrd,
1642        Ord,
1643        Serialize,
1644        Deserialize
1645    )]
1646    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1647    pub struct Entry {
1648        pub key: Option<RoleId>,
1649        pub value: Option<RoleId>,
1650    }
1651}
1652
1653#[derive(
1654    Clone,
1655    Debug,
1656    Default,
1657    PartialEq,
1658    Eq,
1659    PartialOrd,
1660    Ord,
1661    Serialize,
1662    Deserialize
1663)]
1664#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1665pub struct RoleVars {
1666    pub entries: Vec<role_vars::Entry>,
1667}
1668
1669pub mod role_vars {
1670    use super::*;
1671
1672    #[derive(
1673        Clone,
1674        Debug,
1675        Default,
1676        PartialEq,
1677        Eq,
1678        PartialOrd,
1679        Ord,
1680        Serialize,
1681        Deserialize
1682    )]
1683    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1684    pub struct SqlSet {
1685        pub entries: Vec<String>,
1686    }
1687
1688    #[derive(
1689        Clone,
1690        Debug,
1691        Default,
1692        PartialEq,
1693        Eq,
1694        PartialOrd,
1695        Ord,
1696        Serialize,
1697        Deserialize
1698    )]
1699    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1700    pub struct Entry {
1701        pub key: String,
1702        pub val: Option<entry::Val>,
1703    }
1704
1705    pub mod entry {
1706        use super::*;
1707
1708        #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
1709        #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1710        pub enum Val {
1711            Flat(String),
1712            SqlSet(SqlSet),
1713        }
1714    }
1715}
1716
1717#[derive(
1718    Clone,
1719    Debug,
1720    Default,
1721    PartialEq,
1722    Eq,
1723    PartialOrd,
1724    Ord,
1725    Serialize,
1726    Deserialize
1727)]
1728#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1729pub struct NetworkPolicyRule {
1730    pub name: String,
1731    pub address: String,
1732    pub action: Option<network_policy_rule::Action>,
1733    pub direction: Option<network_policy_rule::Direction>,
1734}
1735
1736pub mod network_policy_rule {
1737    use super::*;
1738
1739    #[derive(
1740        Clone,
1741        Copy,
1742        Debug,
1743        PartialEq,
1744        Eq,
1745        PartialOrd,
1746        Ord,
1747        Serialize,
1748        Deserialize
1749    )]
1750    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1751    pub enum Action {
1752        Allow(Empty),
1753    }
1754
1755    #[derive(
1756        Clone,
1757        Copy,
1758        Debug,
1759        PartialEq,
1760        Eq,
1761        PartialOrd,
1762        Ord,
1763        Serialize,
1764        Deserialize
1765    )]
1766    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1767    pub enum Direction {
1768        Ingress(Empty),
1769    }
1770}
1771
1772#[derive(
1773    Clone,
1774    Copy,
1775    Debug,
1776    Default,
1777    PartialEq,
1778    Eq,
1779    PartialOrd,
1780    Ord,
1781    Serialize,
1782    Deserialize
1783)]
1784#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1785pub struct AclMode {
1786    pub bitflags: u64,
1787}
1788
1789#[derive(
1790    Clone,
1791    Copy,
1792    Debug,
1793    Default,
1794    PartialEq,
1795    Eq,
1796    PartialOrd,
1797    Ord,
1798    Serialize,
1799    Deserialize
1800)]
1801#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1802pub struct MzAclItem {
1803    pub grantee: Option<RoleId>,
1804    pub grantor: Option<RoleId>,
1805    pub acl_mode: Option<AclMode>,
1806}
1807
1808#[derive(
1809    Clone,
1810    Copy,
1811    Debug,
1812    Default,
1813    PartialEq,
1814    Eq,
1815    PartialOrd,
1816    Ord,
1817    Serialize,
1818    Deserialize
1819)]
1820#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1821pub struct DefaultPrivilegesKey {
1822    pub role_id: Option<RoleId>,
1823    pub database_id: Option<DatabaseId>,
1824    pub schema_id: Option<SchemaId>,
1825    pub object_type: i32,
1826    pub grantee: Option<RoleId>,
1827}
1828
1829#[derive(
1830    Clone,
1831    Copy,
1832    Debug,
1833    Default,
1834    PartialEq,
1835    Eq,
1836    PartialOrd,
1837    Ord,
1838    Serialize,
1839    Deserialize
1840)]
1841#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1842pub struct DefaultPrivilegesValue {
1843    pub privileges: Option<AclMode>,
1844}
1845
1846#[derive(
1847    Clone,
1848    Copy,
1849    Debug,
1850    Default,
1851    PartialEq,
1852    Eq,
1853    PartialOrd,
1854    Ord,
1855    Serialize,
1856    Deserialize
1857)]
1858#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1859pub struct SystemPrivilegesKey {
1860    pub grantee: Option<RoleId>,
1861    pub grantor: Option<RoleId>,
1862}
1863
1864#[derive(
1865    Clone,
1866    Copy,
1867    Debug,
1868    Default,
1869    PartialEq,
1870    Eq,
1871    PartialOrd,
1872    Ord,
1873    Serialize,
1874    Deserialize
1875)]
1876#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1877pub struct SystemPrivilegesValue {
1878    pub acl_mode: Option<AclMode>,
1879}
1880
1881#[derive(
1882    Clone,
1883    Debug,
1884    Default,
1885    PartialEq,
1886    Eq,
1887    PartialOrd,
1888    Ord,
1889    Serialize,
1890    Deserialize
1891)]
1892#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1893pub struct AuditLogEventV1 {
1894    pub id: u64,
1895    pub event_type: i32,
1896    pub object_type: i32,
1897    pub user: Option<StringWrapper>,
1898    pub occurred_at: Option<EpochMillis>,
1899    pub details: Option<audit_log_event_v1::Details>,
1900}
1901
1902pub mod audit_log_event_v1 {
1903    use super::*;
1904
1905    #[derive(
1906        Clone,
1907        Debug,
1908        Default,
1909        PartialEq,
1910        Eq,
1911        PartialOrd,
1912        Ord,
1913        Serialize,
1914        Deserialize
1915    )]
1916    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1917    pub struct IdFullNameV1 {
1918        pub id: String,
1919        pub name: Option<FullNameV1>,
1920    }
1921
1922    #[derive(
1923        Clone,
1924        Debug,
1925        Default,
1926        PartialEq,
1927        Eq,
1928        PartialOrd,
1929        Ord,
1930        Serialize,
1931        Deserialize
1932    )]
1933    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1934    pub struct FullNameV1 {
1935        pub database: String,
1936        pub schema: String,
1937        pub item: String,
1938    }
1939
1940    #[derive(
1941        Clone,
1942        Debug,
1943        Default,
1944        PartialEq,
1945        Eq,
1946        PartialOrd,
1947        Ord,
1948        Serialize,
1949        Deserialize
1950    )]
1951    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1952    pub struct IdNameV1 {
1953        pub id: String,
1954        pub name: String,
1955    }
1956
1957    #[derive(
1958        Clone,
1959        Debug,
1960        Default,
1961        PartialEq,
1962        Eq,
1963        PartialOrd,
1964        Ord,
1965        Serialize,
1966        Deserialize
1967    )]
1968    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1969    pub struct RenameClusterV1 {
1970        pub id: String,
1971        pub old_name: String,
1972        pub new_name: String,
1973    }
1974
1975    #[derive(
1976        Clone,
1977        Debug,
1978        Default,
1979        PartialEq,
1980        Eq,
1981        PartialOrd,
1982        Ord,
1983        Serialize,
1984        Deserialize
1985    )]
1986    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
1987    pub struct RenameClusterReplicaV1 {
1988        pub cluster_id: String,
1989        pub replica_id: String,
1990        pub old_name: String,
1991        pub new_name: String,
1992    }
1993
1994    #[derive(
1995        Clone,
1996        Debug,
1997        Default,
1998        PartialEq,
1999        Eq,
2000        PartialOrd,
2001        Ord,
2002        Serialize,
2003        Deserialize
2004    )]
2005    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2006    pub struct RenameItemV1 {
2007        pub id: String,
2008        pub old_name: Option<FullNameV1>,
2009        pub new_name: Option<FullNameV1>,
2010    }
2011
2012    #[derive(
2013        Clone,
2014        Debug,
2015        Default,
2016        PartialEq,
2017        Eq,
2018        PartialOrd,
2019        Ord,
2020        Serialize,
2021        Deserialize
2022    )]
2023    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2024    pub struct CreateClusterReplicaV1 {
2025        pub cluster_id: String,
2026        pub cluster_name: String,
2027        pub replica_id: Option<StringWrapper>,
2028        pub replica_name: String,
2029        pub logical_size: String,
2030        pub disk: bool,
2031        pub billed_as: Option<String>,
2032        pub internal: bool,
2033    }
2034
2035    #[derive(
2036        Clone,
2037        Debug,
2038        Default,
2039        PartialEq,
2040        Eq,
2041        PartialOrd,
2042        Ord,
2043        Serialize,
2044        Deserialize
2045    )]
2046    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2047    pub struct CreateClusterReplicaV2 {
2048        pub cluster_id: String,
2049        pub cluster_name: String,
2050        pub replica_id: Option<StringWrapper>,
2051        pub replica_name: String,
2052        pub logical_size: String,
2053        pub disk: bool,
2054        pub billed_as: Option<String>,
2055        pub internal: bool,
2056        pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2057        pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV1>,
2058    }
2059
2060    #[derive(
2061        Clone,
2062        Debug,
2063        Default,
2064        PartialEq,
2065        Eq,
2066        PartialOrd,
2067        Ord,
2068        Serialize,
2069        Deserialize
2070    )]
2071    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2072    pub struct CreateClusterReplicaV3 {
2073        pub cluster_id: String,
2074        pub cluster_name: String,
2075        pub replica_id: Option<StringWrapper>,
2076        pub replica_name: String,
2077        pub logical_size: String,
2078        pub disk: bool,
2079        pub billed_as: Option<String>,
2080        pub internal: bool,
2081        pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2082        pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
2083    }
2084
2085    #[derive(
2086        Clone,
2087        Debug,
2088        Default,
2089        PartialEq,
2090        Eq,
2091        PartialOrd,
2092        Ord,
2093        Serialize,
2094        Deserialize
2095    )]
2096    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2097    pub struct DropClusterReplicaV1 {
2098        pub cluster_id: String,
2099        pub cluster_name: String,
2100        pub replica_id: Option<StringWrapper>,
2101        pub replica_name: String,
2102    }
2103
2104    #[derive(
2105        Clone,
2106        Debug,
2107        Default,
2108        PartialEq,
2109        Eq,
2110        PartialOrd,
2111        Ord,
2112        Serialize,
2113        Deserialize
2114    )]
2115    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2116    pub struct DropClusterReplicaV2 {
2117        pub cluster_id: String,
2118        pub cluster_name: String,
2119        pub replica_id: Option<StringWrapper>,
2120        pub replica_name: String,
2121        pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2122        pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV1>,
2123    }
2124
2125    #[derive(
2126        Clone,
2127        Debug,
2128        Default,
2129        PartialEq,
2130        Eq,
2131        PartialOrd,
2132        Ord,
2133        Serialize,
2134        Deserialize
2135    )]
2136    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2137    pub struct DropClusterReplicaV3 {
2138        pub cluster_id: String,
2139        pub cluster_name: String,
2140        pub replica_id: Option<StringWrapper>,
2141        pub replica_name: String,
2142        pub reason: Option<CreateOrDropClusterReplicaReasonV1>,
2143        pub scheduling_policies: Option<SchedulingDecisionsWithReasonsV2>,
2144    }
2145
2146    #[derive(
2147        Clone,
2148        Copy,
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 CreateOrDropClusterReplicaReasonV1 {
2160        pub reason: Option<create_or_drop_cluster_replica_reason_v1::Reason>,
2161    }
2162
2163    pub mod create_or_drop_cluster_replica_reason_v1 {
2164        use super::*;
2165
2166        #[derive(
2167            Clone,
2168            Copy,
2169            Debug,
2170            PartialEq,
2171            Eq,
2172            PartialOrd,
2173            Ord,
2174            Serialize,
2175            Deserialize
2176        )]
2177        #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2178        pub enum Reason {
2179            Manual(Empty),
2180            Schedule(Empty),
2181            System(Empty),
2182        }
2183    }
2184
2185    #[derive(
2186        Clone,
2187        Debug,
2188        Default,
2189        PartialEq,
2190        Eq,
2191        PartialOrd,
2192        Ord,
2193        Serialize,
2194        Deserialize
2195    )]
2196    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2197    pub struct SchedulingDecisionsWithReasonsV1 {
2198        pub on_refresh: Option<RefreshDecisionWithReasonV1>,
2199    }
2200
2201    #[derive(
2202        Clone,
2203        Debug,
2204        Default,
2205        PartialEq,
2206        Eq,
2207        PartialOrd,
2208        Ord,
2209        Serialize,
2210        Deserialize
2211    )]
2212    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2213    pub struct SchedulingDecisionsWithReasonsV2 {
2214        pub on_refresh: Option<RefreshDecisionWithReasonV2>,
2215    }
2216
2217    #[derive(
2218        Clone,
2219        Debug,
2220        Default,
2221        PartialEq,
2222        Eq,
2223        PartialOrd,
2224        Ord,
2225        Serialize,
2226        Deserialize
2227    )]
2228    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2229    pub struct RefreshDecisionWithReasonV1 {
2230        pub objects_needing_refresh: Vec<String>,
2231        pub rehydration_time_estimate: String,
2232        pub decision: Option<refresh_decision_with_reason_v1::Decision>,
2233    }
2234
2235    pub mod refresh_decision_with_reason_v1 {
2236        use super::*;
2237
2238        #[derive(
2239            Clone,
2240            Copy,
2241            Debug,
2242            PartialEq,
2243            Eq,
2244            PartialOrd,
2245            Ord,
2246            Serialize,
2247            Deserialize
2248        )]
2249        #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2250        pub enum Decision {
2251            On(Empty),
2252            Off(Empty),
2253        }
2254    }
2255
2256    #[derive(
2257        Clone,
2258        Debug,
2259        Default,
2260        PartialEq,
2261        Eq,
2262        PartialOrd,
2263        Ord,
2264        Serialize,
2265        Deserialize
2266    )]
2267    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2268    pub struct RefreshDecisionWithReasonV2 {
2269        pub objects_needing_refresh: Vec<String>,
2270        pub objects_needing_compaction: Vec<String>,
2271        pub rehydration_time_estimate: String,
2272        pub decision: Option<refresh_decision_with_reason_v2::Decision>,
2273    }
2274
2275    pub mod refresh_decision_with_reason_v2 {
2276        use super::*;
2277
2278        #[derive(
2279            Clone,
2280            Copy,
2281            Debug,
2282            PartialEq,
2283            Eq,
2284            PartialOrd,
2285            Ord,
2286            Serialize,
2287            Deserialize
2288        )]
2289        #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2290        pub enum Decision {
2291            On(Empty),
2292            Off(Empty),
2293        }
2294    }
2295
2296    #[derive(
2297        Clone,
2298        Debug,
2299        Default,
2300        PartialEq,
2301        Eq,
2302        PartialOrd,
2303        Ord,
2304        Serialize,
2305        Deserialize
2306    )]
2307    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2308    pub struct CreateSourceSinkV1 {
2309        pub id: String,
2310        pub name: Option<FullNameV1>,
2311        pub size: Option<StringWrapper>,
2312    }
2313
2314    #[derive(
2315        Clone,
2316        Debug,
2317        Default,
2318        PartialEq,
2319        Eq,
2320        PartialOrd,
2321        Ord,
2322        Serialize,
2323        Deserialize
2324    )]
2325    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2326    pub struct CreateSourceSinkV2 {
2327        pub id: String,
2328        pub name: Option<FullNameV1>,
2329        pub size: Option<StringWrapper>,
2330        pub external_type: String,
2331    }
2332
2333    #[derive(
2334        Clone,
2335        Debug,
2336        Default,
2337        PartialEq,
2338        Eq,
2339        PartialOrd,
2340        Ord,
2341        Serialize,
2342        Deserialize
2343    )]
2344    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2345    pub struct CreateSourceSinkV3 {
2346        pub id: String,
2347        pub name: Option<FullNameV1>,
2348        pub external_type: String,
2349    }
2350
2351    #[derive(
2352        Clone,
2353        Debug,
2354        Default,
2355        PartialEq,
2356        Eq,
2357        PartialOrd,
2358        Ord,
2359        Serialize,
2360        Deserialize
2361    )]
2362    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2363    pub struct CreateSourceSinkV4 {
2364        pub id: String,
2365        pub cluster_id: Option<StringWrapper>,
2366        pub name: Option<FullNameV1>,
2367        pub external_type: String,
2368    }
2369
2370    #[derive(
2371        Clone,
2372        Debug,
2373        Default,
2374        PartialEq,
2375        Eq,
2376        PartialOrd,
2377        Ord,
2378        Serialize,
2379        Deserialize
2380    )]
2381    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2382    pub struct CreateIndexV1 {
2383        pub id: String,
2384        pub cluster_id: String,
2385        pub name: Option<FullNameV1>,
2386    }
2387
2388    #[derive(
2389        Clone,
2390        Debug,
2391        Default,
2392        PartialEq,
2393        Eq,
2394        PartialOrd,
2395        Ord,
2396        Serialize,
2397        Deserialize
2398    )]
2399    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2400    pub struct CreateMaterializedViewV1 {
2401        pub id: String,
2402        pub cluster_id: String,
2403        pub name: Option<FullNameV1>,
2404    }
2405
2406    #[derive(
2407        Clone,
2408        Debug,
2409        Default,
2410        PartialEq,
2411        Eq,
2412        PartialOrd,
2413        Ord,
2414        Serialize,
2415        Deserialize
2416    )]
2417    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2418    pub struct AlterSourceSinkV1 {
2419        pub id: String,
2420        pub name: Option<FullNameV1>,
2421        pub old_size: Option<StringWrapper>,
2422        pub new_size: Option<StringWrapper>,
2423    }
2424
2425    #[derive(
2426        Clone,
2427        Debug,
2428        Default,
2429        PartialEq,
2430        Eq,
2431        PartialOrd,
2432        Ord,
2433        Serialize,
2434        Deserialize
2435    )]
2436    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2437    pub struct AlterSetClusterV1 {
2438        pub id: String,
2439        pub name: Option<FullNameV1>,
2440        pub old_cluster: Option<StringWrapper>,
2441        pub new_cluster: Option<StringWrapper>,
2442    }
2443
2444    #[derive(
2445        Clone,
2446        Debug,
2447        Default,
2448        PartialEq,
2449        Eq,
2450        PartialOrd,
2451        Ord,
2452        Serialize,
2453        Deserialize
2454    )]
2455    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2456    pub struct GrantRoleV1 {
2457        pub role_id: String,
2458        pub member_id: String,
2459        pub grantor_id: String,
2460    }
2461
2462    #[derive(
2463        Clone,
2464        Debug,
2465        Default,
2466        PartialEq,
2467        Eq,
2468        PartialOrd,
2469        Ord,
2470        Serialize,
2471        Deserialize
2472    )]
2473    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2474    pub struct GrantRoleV2 {
2475        pub role_id: String,
2476        pub member_id: String,
2477        pub grantor_id: String,
2478        pub executed_by: String,
2479    }
2480
2481    #[derive(
2482        Clone,
2483        Debug,
2484        Default,
2485        PartialEq,
2486        Eq,
2487        PartialOrd,
2488        Ord,
2489        Serialize,
2490        Deserialize
2491    )]
2492    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2493    pub struct RevokeRoleV1 {
2494        pub role_id: String,
2495        pub member_id: String,
2496    }
2497
2498    #[derive(
2499        Clone,
2500        Debug,
2501        Default,
2502        PartialEq,
2503        Eq,
2504        PartialOrd,
2505        Ord,
2506        Serialize,
2507        Deserialize
2508    )]
2509    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2510    pub struct RevokeRoleV2 {
2511        pub role_id: String,
2512        pub member_id: String,
2513        pub grantor_id: String,
2514        pub executed_by: String,
2515    }
2516
2517    #[derive(
2518        Clone,
2519        Debug,
2520        Default,
2521        PartialEq,
2522        Eq,
2523        PartialOrd,
2524        Ord,
2525        Serialize,
2526        Deserialize
2527    )]
2528    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2529    pub struct UpdatePrivilegeV1 {
2530        pub object_id: String,
2531        pub grantee_id: String,
2532        pub grantor_id: String,
2533        pub privileges: String,
2534    }
2535
2536    #[derive(
2537        Clone,
2538        Debug,
2539        Default,
2540        PartialEq,
2541        Eq,
2542        PartialOrd,
2543        Ord,
2544        Serialize,
2545        Deserialize
2546    )]
2547    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2548    pub struct AlterDefaultPrivilegeV1 {
2549        pub role_id: String,
2550        pub database_id: Option<StringWrapper>,
2551        pub schema_id: Option<StringWrapper>,
2552        pub grantee_id: String,
2553        pub privileges: String,
2554    }
2555
2556    #[derive(
2557        Clone,
2558        Debug,
2559        Default,
2560        PartialEq,
2561        Eq,
2562        PartialOrd,
2563        Ord,
2564        Serialize,
2565        Deserialize
2566    )]
2567    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2568    pub struct UpdateOwnerV1 {
2569        pub object_id: String,
2570        pub old_owner_id: String,
2571        pub new_owner_id: String,
2572    }
2573
2574    #[derive(
2575        Clone,
2576        Debug,
2577        Default,
2578        PartialEq,
2579        Eq,
2580        PartialOrd,
2581        Ord,
2582        Serialize,
2583        Deserialize
2584    )]
2585    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2586    pub struct SchemaV1 {
2587        pub id: String,
2588        pub name: String,
2589        pub database_name: String,
2590    }
2591
2592    #[derive(
2593        Clone,
2594        Debug,
2595        Default,
2596        PartialEq,
2597        Eq,
2598        PartialOrd,
2599        Ord,
2600        Serialize,
2601        Deserialize
2602    )]
2603    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2604    pub struct SchemaV2 {
2605        pub id: String,
2606        pub name: String,
2607        pub database_name: Option<StringWrapper>,
2608    }
2609
2610    #[derive(
2611        Clone,
2612        Debug,
2613        Default,
2614        PartialEq,
2615        Eq,
2616        PartialOrd,
2617        Ord,
2618        Serialize,
2619        Deserialize
2620    )]
2621    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2622    pub struct RenameSchemaV1 {
2623        pub id: String,
2624        pub database_name: Option<String>,
2625        pub old_name: String,
2626        pub new_name: String,
2627    }
2628
2629    #[derive(
2630        Clone,
2631        Debug,
2632        Default,
2633        PartialEq,
2634        Eq,
2635        PartialOrd,
2636        Ord,
2637        Serialize,
2638        Deserialize
2639    )]
2640    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2641    pub struct UpdateItemV1 {
2642        pub id: String,
2643        pub name: Option<FullNameV1>,
2644    }
2645
2646    #[derive(
2647        Clone,
2648        Debug,
2649        Default,
2650        PartialEq,
2651        Eq,
2652        PartialOrd,
2653        Ord,
2654        Serialize,
2655        Deserialize
2656    )]
2657    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2658    pub struct AlterRetainHistoryV1 {
2659        pub id: String,
2660        pub old_history: Option<String>,
2661        pub new_history: Option<String>,
2662    }
2663
2664    #[derive(
2665        Clone,
2666        Debug,
2667        Default,
2668        PartialEq,
2669        Eq,
2670        PartialOrd,
2671        Ord,
2672        Serialize,
2673        Deserialize
2674    )]
2675    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2676    pub struct ToNewIdV1 {
2677        pub id: String,
2678        pub new_id: String,
2679    }
2680
2681    #[derive(
2682        Clone,
2683        Debug,
2684        Default,
2685        PartialEq,
2686        Eq,
2687        PartialOrd,
2688        Ord,
2689        Serialize,
2690        Deserialize
2691    )]
2692    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2693    pub struct FromPreviousIdV1 {
2694        pub id: String,
2695        pub previous_id: String,
2696    }
2697
2698    #[derive(
2699        Clone,
2700        Debug,
2701        Default,
2702        PartialEq,
2703        Eq,
2704        PartialOrd,
2705        Ord,
2706        Serialize,
2707        Deserialize
2708    )]
2709    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2710    pub struct SetV1 {
2711        pub name: String,
2712        pub value: Option<String>,
2713    }
2714
2715    #[derive(
2716        Clone,
2717        Debug,
2718        Default,
2719        PartialEq,
2720        Eq,
2721        PartialOrd,
2722        Ord,
2723        Serialize,
2724        Deserialize
2725    )]
2726    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2727    pub struct RotateKeysV1 {
2728        pub id: String,
2729        pub name: String,
2730    }
2731
2732    #[derive(
2733        Clone,
2734        Copy,
2735        Debug,
2736        PartialEq,
2737        Eq,
2738        Hash,
2739        PartialOrd,
2740        Ord,
2741        IntoPrimitive,
2742        TryFromPrimitive
2743    )]
2744    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2745    #[repr(i32)]
2746    pub enum EventType {
2747        Unknown = 0,
2748        Create = 1,
2749        Drop = 2,
2750        Alter = 3,
2751        Grant = 4,
2752        Revoke = 5,
2753        Comment = 6,
2754    }
2755
2756    #[derive(
2757        Clone,
2758        Copy,
2759        Debug,
2760        PartialEq,
2761        Eq,
2762        Hash,
2763        PartialOrd,
2764        Ord,
2765        IntoPrimitive,
2766        TryFromPrimitive
2767    )]
2768    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2769    #[repr(i32)]
2770    pub enum ObjectType {
2771        Unknown = 0,
2772        Cluster = 1,
2773        ClusterReplica = 2,
2774        Connection = 3,
2775        Database = 4,
2776        Func = 5,
2777        Index = 6,
2778        MaterializedView = 7,
2779        Role = 8,
2780        Secret = 9,
2781        Schema = 10,
2782        Sink = 11,
2783        Source = 12,
2784        Table = 13,
2785        Type = 14,
2786        View = 15,
2787        System = 16,
2788        ContinualTask = 17,
2789        NetworkPolicy = 18,
2790    }
2791    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
2792    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2793    pub enum Details {
2794        CreateClusterReplicaV1(CreateClusterReplicaV1),
2795        CreateClusterReplicaV2(CreateClusterReplicaV2),
2796        CreateClusterReplicaV3(CreateClusterReplicaV3),
2797        DropClusterReplicaV1(DropClusterReplicaV1),
2798        DropClusterReplicaV2(DropClusterReplicaV2),
2799        DropClusterReplicaV3(DropClusterReplicaV3),
2800        CreateSourceSinkV1(CreateSourceSinkV1),
2801        CreateSourceSinkV2(CreateSourceSinkV2),
2802        AlterSourceSinkV1(AlterSourceSinkV1),
2803        AlterSetClusterV1(AlterSetClusterV1),
2804        GrantRoleV1(GrantRoleV1),
2805        GrantRoleV2(GrantRoleV2),
2806        RevokeRoleV1(RevokeRoleV1),
2807        RevokeRoleV2(RevokeRoleV2),
2808        UpdatePrivilegeV1(UpdatePrivilegeV1),
2809        AlterDefaultPrivilegeV1(AlterDefaultPrivilegeV1),
2810        UpdateOwnerV1(UpdateOwnerV1),
2811        IdFullNameV1(IdFullNameV1),
2812        RenameClusterV1(RenameClusterV1),
2813        RenameClusterReplicaV1(RenameClusterReplicaV1),
2814        RenameItemV1(RenameItemV1),
2815        IdNameV1(IdNameV1),
2816        SchemaV1(SchemaV1),
2817        SchemaV2(SchemaV2),
2818        RenameSchemaV1(RenameSchemaV1),
2819        UpdateItemV1(UpdateItemV1),
2820        CreateSourceSinkV3(CreateSourceSinkV3),
2821        AlterRetainHistoryV1(AlterRetainHistoryV1),
2822        ToNewIdV1(ToNewIdV1),
2823        FromPreviousIdV1(FromPreviousIdV1),
2824        SetV1(SetV1),
2825        ResetAllV1(Empty),
2826        RotateKeysV1(RotateKeysV1),
2827        CreateSourceSinkV4(CreateSourceSinkV4),
2828        CreateIndexV1(CreateIndexV1),
2829        CreateMaterializedViewV1(CreateMaterializedViewV1),
2830    }
2831}
2832
2833#[derive(
2834    Clone,
2835    Debug,
2836    Default,
2837    PartialEq,
2838    Eq,
2839    PartialOrd,
2840    Ord,
2841    Serialize,
2842    Deserialize
2843)]
2844#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2845pub struct StateUpdateKind {
2846    pub kind: Option<state_update_kind::Kind>,
2847}
2848
2849pub mod state_update_kind {
2850    use super::*;
2851
2852    #[derive(
2853        Clone,
2854        Debug,
2855        Default,
2856        PartialEq,
2857        Eq,
2858        PartialOrd,
2859        Ord,
2860        Serialize,
2861        Deserialize
2862    )]
2863    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2864    pub struct AuditLog {
2865        pub key: Option<AuditLogKey>,
2866    }
2867
2868    #[derive(
2869        Clone,
2870        Debug,
2871        Default,
2872        PartialEq,
2873        Eq,
2874        PartialOrd,
2875        Ord,
2876        Serialize,
2877        Deserialize
2878    )]
2879    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2880    pub struct Cluster {
2881        pub key: Option<ClusterKey>,
2882        pub value: Option<ClusterValue>,
2883    }
2884
2885    #[derive(
2886        Clone,
2887        Debug,
2888        Default,
2889        PartialEq,
2890        Eq,
2891        PartialOrd,
2892        Ord,
2893        Serialize,
2894        Deserialize
2895    )]
2896    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2897    pub struct ClusterReplica {
2898        pub key: Option<ClusterReplicaKey>,
2899        pub value: Option<ClusterReplicaValue>,
2900    }
2901
2902    #[derive(
2903        Clone,
2904        Debug,
2905        Default,
2906        PartialEq,
2907        Eq,
2908        PartialOrd,
2909        Ord,
2910        Serialize,
2911        Deserialize
2912    )]
2913    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2914    pub struct Comment {
2915        pub key: Option<CommentKey>,
2916        pub value: Option<CommentValue>,
2917    }
2918
2919    #[derive(
2920        Clone,
2921        Debug,
2922        Default,
2923        PartialEq,
2924        Eq,
2925        PartialOrd,
2926        Ord,
2927        Serialize,
2928        Deserialize
2929    )]
2930    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2931    pub struct Config {
2932        pub key: Option<ConfigKey>,
2933        pub value: Option<ConfigValue>,
2934    }
2935
2936    #[derive(
2937        Clone,
2938        Debug,
2939        Default,
2940        PartialEq,
2941        Eq,
2942        PartialOrd,
2943        Ord,
2944        Serialize,
2945        Deserialize
2946    )]
2947    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2948    pub struct Database {
2949        pub key: Option<DatabaseKey>,
2950        pub value: Option<DatabaseValue>,
2951    }
2952
2953    #[derive(
2954        Clone,
2955        Copy,
2956        Debug,
2957        Default,
2958        PartialEq,
2959        Eq,
2960        PartialOrd,
2961        Ord,
2962        Serialize,
2963        Deserialize
2964    )]
2965    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2966    pub struct DefaultPrivileges {
2967        pub key: Option<DefaultPrivilegesKey>,
2968        pub value: Option<DefaultPrivilegesValue>,
2969    }
2970
2971    #[derive(
2972        Clone,
2973        Copy,
2974        Debug,
2975        Default,
2976        PartialEq,
2977        Eq,
2978        PartialOrd,
2979        Ord,
2980        Serialize,
2981        Deserialize
2982    )]
2983    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
2984    pub struct FenceToken {
2985        pub deploy_generation: u64,
2986        pub epoch: i64,
2987    }
2988
2989    #[derive(
2990        Clone,
2991        Debug,
2992        Default,
2993        PartialEq,
2994        Eq,
2995        PartialOrd,
2996        Ord,
2997        Serialize,
2998        Deserialize
2999    )]
3000    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3001    pub struct IdAlloc {
3002        pub key: Option<IdAllocKey>,
3003        pub value: Option<IdAllocValue>,
3004    }
3005
3006    #[derive(
3007        Clone,
3008        Debug,
3009        Default,
3010        PartialEq,
3011        Eq,
3012        PartialOrd,
3013        Ord,
3014        Serialize,
3015        Deserialize
3016    )]
3017    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3018    pub struct ClusterIntrospectionSourceIndex {
3019        pub key: Option<ClusterIntrospectionSourceIndexKey>,
3020        pub value: Option<ClusterIntrospectionSourceIndexValue>,
3021    }
3022
3023    #[derive(
3024        Clone,
3025        Debug,
3026        Default,
3027        PartialEq,
3028        Eq,
3029        PartialOrd,
3030        Ord,
3031        Serialize,
3032        Deserialize
3033    )]
3034    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3035    pub struct Item {
3036        pub key: Option<ItemKey>,
3037        pub value: Option<ItemValue>,
3038    }
3039
3040    #[derive(
3041        Clone,
3042        Debug,
3043        Default,
3044        PartialEq,
3045        Eq,
3046        PartialOrd,
3047        Ord,
3048        Serialize,
3049        Deserialize
3050    )]
3051    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3052    pub struct Role {
3053        pub key: Option<RoleKey>,
3054        pub value: Option<RoleValue>,
3055    }
3056
3057    #[derive(
3058        Clone,
3059        Debug,
3060        Default,
3061        PartialEq,
3062        Eq,
3063        PartialOrd,
3064        Ord,
3065        Serialize,
3066        Deserialize
3067    )]
3068    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3069    pub struct RoleAuth {
3070        pub key: Option<RoleAuthKey>,
3071        pub value: Option<RoleAuthValue>,
3072    }
3073
3074    #[derive(
3075        Clone,
3076        Debug,
3077        Default,
3078        PartialEq,
3079        Eq,
3080        PartialOrd,
3081        Ord,
3082        Serialize,
3083        Deserialize
3084    )]
3085    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3086    pub struct NetworkPolicy {
3087        pub key: Option<NetworkPolicyKey>,
3088        pub value: Option<NetworkPolicyValue>,
3089    }
3090
3091    #[derive(
3092        Clone,
3093        Debug,
3094        Default,
3095        PartialEq,
3096        Eq,
3097        PartialOrd,
3098        Ord,
3099        Serialize,
3100        Deserialize
3101    )]
3102    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3103    pub struct Schema {
3104        pub key: Option<SchemaKey>,
3105        pub value: Option<SchemaValue>,
3106    }
3107
3108    #[derive(
3109        Clone,
3110        Debug,
3111        Default,
3112        PartialEq,
3113        Eq,
3114        PartialOrd,
3115        Ord,
3116        Serialize,
3117        Deserialize
3118    )]
3119    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3120    pub struct Setting {
3121        pub key: Option<SettingKey>,
3122        pub value: Option<SettingValue>,
3123    }
3124
3125    #[derive(
3126        Clone,
3127        Debug,
3128        Default,
3129        PartialEq,
3130        Eq,
3131        PartialOrd,
3132        Ord,
3133        Serialize,
3134        Deserialize
3135    )]
3136    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3137    pub struct ServerConfiguration {
3138        pub key: Option<ServerConfigurationKey>,
3139        pub value: Option<ServerConfigurationValue>,
3140    }
3141
3142    #[derive(
3143        Clone,
3144        Debug,
3145        Default,
3146        PartialEq,
3147        Eq,
3148        PartialOrd,
3149        Ord,
3150        Serialize,
3151        Deserialize
3152    )]
3153    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3154    pub struct SourceReferences {
3155        pub key: Option<SourceReferencesKey>,
3156        pub value: Option<SourceReferencesValue>,
3157    }
3158
3159    #[derive(
3160        Clone,
3161        Debug,
3162        Default,
3163        PartialEq,
3164        Eq,
3165        PartialOrd,
3166        Ord,
3167        Serialize,
3168        Deserialize
3169    )]
3170    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3171    pub struct GidMapping {
3172        pub key: Option<GidMappingKey>,
3173        pub value: Option<GidMappingValue>,
3174    }
3175
3176    #[derive(
3177        Clone,
3178        Copy,
3179        Debug,
3180        Default,
3181        PartialEq,
3182        Eq,
3183        PartialOrd,
3184        Ord,
3185        Serialize,
3186        Deserialize
3187    )]
3188    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3189    pub struct SystemPrivileges {
3190        pub key: Option<SystemPrivilegesKey>,
3191        pub value: Option<SystemPrivilegesValue>,
3192    }
3193
3194    #[derive(
3195        Clone,
3196        Debug,
3197        Default,
3198        PartialEq,
3199        Eq,
3200        PartialOrd,
3201        Ord,
3202        Serialize,
3203        Deserialize
3204    )]
3205    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3206    pub struct StorageCollectionMetadata {
3207        pub key: Option<StorageCollectionMetadataKey>,
3208        pub value: Option<StorageCollectionMetadataValue>,
3209    }
3210
3211    #[derive(
3212        Clone,
3213        Debug,
3214        Default,
3215        PartialEq,
3216        Eq,
3217        PartialOrd,
3218        Ord,
3219        Serialize,
3220        Deserialize
3221    )]
3222    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3223    pub struct UnfinalizedShard {
3224        pub key: Option<UnfinalizedShardKey>,
3225    }
3226
3227    #[derive(
3228        Clone,
3229        Debug,
3230        Default,
3231        PartialEq,
3232        Eq,
3233        PartialOrd,
3234        Ord,
3235        Serialize,
3236        Deserialize
3237    )]
3238    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3239    pub struct TxnWalShard {
3240        pub value: Option<TxnWalShardValue>,
3241    }
3242
3243    #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
3244    #[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3245    // Serialize the top-level enum in the persist-backed catalog as internally tagged to set up
3246    // persist pushdown statistics for success.
3247    #[serde(tag = "kind")]
3248    pub enum Kind {
3249        AuditLog(AuditLog),
3250        Cluster(Cluster),
3251        ClusterReplica(ClusterReplica),
3252        Comment(Comment),
3253        Config(Config),
3254        Database(Database),
3255        DefaultPrivileges(DefaultPrivileges),
3256        IdAlloc(IdAlloc),
3257        ClusterIntrospectionSourceIndex(ClusterIntrospectionSourceIndex),
3258        Item(Item),
3259        Role(Role),
3260        Schema(Schema),
3261        Setting(Setting),
3262        ServerConfiguration(ServerConfiguration),
3263        GidMapping(GidMapping),
3264        SystemPrivileges(SystemPrivileges),
3265        StorageCollectionMetadata(StorageCollectionMetadata),
3266        UnfinalizedShard(UnfinalizedShard),
3267        TxnWalShard(TxnWalShard),
3268        SourceReferences(SourceReferences),
3269        FenceToken(FenceToken),
3270        NetworkPolicy(NetworkPolicy),
3271        RoleAuth(RoleAuth),
3272    }
3273}
3274
3275#[derive(
3276    Clone,
3277    Copy,
3278    Debug,
3279    PartialEq,
3280    Eq,
3281    Hash,
3282    PartialOrd,
3283    Ord,
3284    IntoPrimitive,
3285    TryFromPrimitive
3286)]
3287#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3288#[repr(i32)]
3289pub enum CatalogItemType {
3290    Unknown = 0,
3291    Table = 1,
3292    Source = 2,
3293    Sink = 3,
3294    View = 4,
3295    MaterializedView = 5,
3296    Index = 6,
3297    Type = 7,
3298    Func = 8,
3299    Secret = 9,
3300    Connection = 10,
3301    ContinualTask = 11,
3302}
3303
3304#[derive(
3305    Clone,
3306    Copy,
3307    Debug,
3308    PartialEq,
3309    Eq,
3310    Hash,
3311    PartialOrd,
3312    Ord,
3313    IntoPrimitive,
3314    TryFromPrimitive
3315)]
3316#[cfg_attr(any(test, feature = "proptest"), derive(Arbitrary))]
3317#[repr(i32)]
3318pub enum ObjectType {
3319    Unknown = 0,
3320    Table = 1,
3321    View = 2,
3322    MaterializedView = 3,
3323    Source = 4,
3324    Sink = 5,
3325    Index = 6,
3326    Type = 7,
3327    Role = 8,
3328    Cluster = 9,
3329    ClusterReplica = 10,
3330    Secret = 11,
3331    Connection = 12,
3332    Database = 13,
3333    Schema = 14,
3334    Func = 15,
3335    ContinualTask = 16,
3336    NetworkPolicy = 17,
3337}
mz_catalog_protos/objects_v75.rs

mz_catalog_protos/
objects_v75.rs
