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

mz_catalog_protos/
objects_v74.rs
