anytype_rpc/gen/
anytype.model.rs

1// This file is @generated by prost-build.
2#[derive(Clone, PartialEq, ::prost::Message)]
3pub struct SmartBlockSnapshotBase {
4    #[prost(message, repeated, tag = "1")]
5    pub blocks: ::prost::alloc::vec::Vec<Block>,
6    #[prost(message, optional, tag = "2")]
7    pub details: ::core::option::Option<::prost_types::Struct>,
8    #[deprecated]
9    #[prost(message, optional, tag = "3")]
10    pub file_keys: ::core::option::Option<::prost_types::Struct>,
11    #[deprecated]
12    #[prost(message, repeated, tag = "4")]
13    pub extra_relations: ::prost::alloc::vec::Vec<Relation>,
14    #[prost(string, repeated, tag = "5")]
15    pub object_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
16    #[prost(message, optional, tag = "6")]
17    pub collections: ::core::option::Option<::prost_types::Struct>,
18    #[prost(string, repeated, tag = "8")]
19    pub removed_collection_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
20    #[prost(message, repeated, tag = "7")]
21    pub relation_links: ::prost::alloc::vec::Vec<RelationLink>,
22    /// only used for pb backup purposes, ignored in other cases
23    #[prost(string, tag = "9")]
24    pub key: ::prost::alloc::string::String,
25    /// ignored in import/export in favor of createdDate relation. Used to store original user-side object creation timestamp
26    #[prost(int64, tag = "10")]
27    pub original_created_timestamp: i64,
28    #[prost(message, optional, tag = "11")]
29    pub file_info: ::core::option::Option<FileInfo>,
30}
31#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
32pub struct Search {}
33/// Nested message and enum types in `Search`.
34pub mod search {
35    #[derive(Clone, PartialEq, ::prost::Message)]
36    pub struct Result {
37        #[prost(string, tag = "1")]
38        pub object_id: ::prost::alloc::string::String,
39        #[prost(message, optional, tag = "2")]
40        pub details: ::core::option::Option<::prost_types::Struct>,
41        /// meta information about the search result
42        #[prost(message, repeated, tag = "3")]
43        pub meta: ::prost::alloc::vec::Vec<Meta>,
44    }
45    #[derive(Clone, PartialEq, ::prost::Message)]
46    pub struct Meta {
47        /// truncated text with highlights
48        #[prost(string, tag = "1")]
49        pub highlight: ::prost::alloc::string::String,
50        /// ranges of the highlight in the text (using utf-16 runes)
51        #[prost(message, repeated, tag = "2")]
52        pub highlight_ranges: ::prost::alloc::vec::Vec<super::Range>,
53        /// block id where the highlight has been found
54        #[prost(string, tag = "3")]
55        pub block_id: ::prost::alloc::string::String,
56        /// relation key of the block where the highlight has been found
57        #[prost(string, tag = "4")]
58        pub relation_key: ::prost::alloc::string::String,
59        /// contains details for dependent object. E.g. relation option or type. todo: rename to dependantDetails
60        #[prost(message, optional, tag = "5")]
61        pub relation_details: ::core::option::Option<::prost_types::Struct>,
62    }
63    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
64    pub struct Message {}
65    /// Nested message and enum types in `Message`.
66    pub mod message {
67        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
68        pub struct Sort {
69            #[prost(enumeration = "sort::Key", tag = "1")]
70            pub key: i32,
71            #[prost(enumeration = "sort::Type", tag = "2")]
72            pub r#type: i32,
73        }
74        /// Nested message and enum types in `Sort`.
75        pub mod sort {
76            #[derive(
77                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
78            )]
79            #[repr(i32)]
80            pub enum Key {
81                OrderId = 0,
82                Score = 1,
83                CreatedAt = 2,
84                ModifiedAt = 3,
85            }
86            impl Key {
87                /// String value of the enum field names used in the ProtoBuf definition.
88                ///
89                /// The values are not transformed in any way and thus are considered stable
90                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
91                pub fn as_str_name(&self) -> &'static str {
92                    match self {
93                        Self::OrderId => "ORDER_ID",
94                        Self::Score => "SCORE",
95                        Self::CreatedAt => "CREATED_AT",
96                        Self::ModifiedAt => "MODIFIED_AT",
97                    }
98                }
99                /// Creates an enum from field names used in the ProtoBuf definition.
100                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
101                    match value {
102                        "ORDER_ID" => Some(Self::OrderId),
103                        "SCORE" => Some(Self::Score),
104                        "CREATED_AT" => Some(Self::CreatedAt),
105                        "MODIFIED_AT" => Some(Self::ModifiedAt),
106                        _ => None,
107                    }
108                }
109            }
110            #[derive(
111                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
112            )]
113            #[repr(i32)]
114            pub enum Type {
115                Asc = 0,
116                Desc = 1,
117            }
118            impl Type {
119                /// String value of the enum field names used in the ProtoBuf definition.
120                ///
121                /// The values are not transformed in any way and thus are considered stable
122                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
123                pub fn as_str_name(&self) -> &'static str {
124                    match self {
125                        Self::Asc => "Asc",
126                        Self::Desc => "Desc",
127                    }
128                }
129                /// Creates an enum from field names used in the ProtoBuf definition.
130                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
131                    match value {
132                        "Asc" => Some(Self::Asc),
133                        "Desc" => Some(Self::Desc),
134                        _ => None,
135                    }
136                }
137            }
138        }
139        #[derive(Clone, PartialEq, ::prost::Message)]
140        pub struct Result {
141            #[prost(string, tag = "1")]
142            pub chat_id: ::prost::alloc::string::String,
143            #[prost(string, tag = "2")]
144            pub message_id: ::prost::alloc::string::String,
145            #[prost(int64, tag = "3")]
146            pub score: i64,
147            /// truncated text with highlights
148            #[prost(string, tag = "4")]
149            pub highlight: ::prost::alloc::string::String,
150            /// ranges of the highlight in the text (using utf-16 runes)
151            #[prost(message, repeated, tag = "5")]
152            pub highlight_ranges: ::prost::alloc::vec::Vec<super::super::Range>,
153            #[prost(message, optional, tag = "6")]
154            pub message: ::core::option::Option<super::super::ChatMessage>,
155        }
156    }
157}
158#[derive(Clone, PartialEq, ::prost::Message)]
159pub struct Block {
160    #[prost(string, tag = "1")]
161    pub id: ::prost::alloc::string::String,
162    #[prost(message, optional, tag = "2")]
163    pub fields: ::core::option::Option<::prost_types::Struct>,
164    #[prost(message, optional, tag = "3")]
165    pub restrictions: ::core::option::Option<block::Restrictions>,
166    #[prost(string, repeated, tag = "4")]
167    pub children_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
168    #[prost(string, tag = "5")]
169    pub background_color: ::prost::alloc::string::String,
170    #[prost(enumeration = "block::Align", tag = "6")]
171    pub align: i32,
172    #[prost(enumeration = "block::VerticalAlign", tag = "7")]
173    pub vertical_align: i32,
174    #[prost(
175        oneof = "block::ContentValue",
176        tags = "11, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30"
177    )]
178    pub content_value: ::core::option::Option<block::ContentValue>,
179}
180/// Nested message and enum types in `Block`.
181pub mod block {
182    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
183    pub struct Restrictions {
184        #[prost(bool, tag = "1")]
185        pub read: bool,
186        #[prost(bool, tag = "2")]
187        pub edit: bool,
188        #[prost(bool, tag = "3")]
189        pub remove: bool,
190        #[prost(bool, tag = "4")]
191        pub drag: bool,
192        #[prost(bool, tag = "5")]
193        pub drop_on: bool,
194    }
195    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
196    pub struct Content {}
197    /// Nested message and enum types in `Content`.
198    pub mod content {
199        /// Layout have no visual representation, but affects on blocks, that it contains.
200        /// Row/Column layout blocks creates only automatically, after some of a D&D operations, for example
201        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
202        pub struct Layout {
203            #[prost(enumeration = "layout::Style", tag = "1")]
204            pub style: i32,
205        }
206        /// Nested message and enum types in `Layout`.
207        pub mod layout {
208            #[derive(
209                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
210            )]
211            #[repr(i32)]
212            pub enum Style {
213                Row = 0,
214                Column = 1,
215                Div = 2,
216                Header = 3,
217                TableRows = 4,
218                TableColumns = 5,
219            }
220            impl Style {
221                /// String value of the enum field names used in the ProtoBuf definition.
222                ///
223                /// The values are not transformed in any way and thus are considered stable
224                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
225                pub fn as_str_name(&self) -> &'static str {
226                    match self {
227                        Self::Row => "Row",
228                        Self::Column => "Column",
229                        Self::Div => "Div",
230                        Self::Header => "Header",
231                        Self::TableRows => "TableRows",
232                        Self::TableColumns => "TableColumns",
233                    }
234                }
235                /// Creates an enum from field names used in the ProtoBuf definition.
236                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
237                    match value {
238                        "Row" => Some(Self::Row),
239                        "Column" => Some(Self::Column),
240                        "Div" => Some(Self::Div),
241                        "Header" => Some(Self::Header),
242                        "TableRows" => Some(Self::TableRows),
243                        "TableColumns" => Some(Self::TableColumns),
244                        _ => None,
245                    }
246                }
247            }
248        }
249        /// Link: block to link some content from an external sources.
250        #[derive(Clone, PartialEq, ::prost::Message)]
251        pub struct Link {
252            /// id of the target block
253            #[prost(string, tag = "1")]
254            pub target_block_id: ::prost::alloc::string::String,
255            /// deprecated
256            #[prost(enumeration = "link::Style", tag = "2")]
257            pub style: i32,
258            #[prost(message, optional, tag = "3")]
259            pub fields: ::core::option::Option<::prost_types::Struct>,
260            #[prost(enumeration = "link::IconSize", tag = "4")]
261            pub icon_size: i32,
262            #[prost(enumeration = "link::CardStyle", tag = "5")]
263            pub card_style: i32,
264            #[prost(enumeration = "link::Description", tag = "6")]
265            pub description: i32,
266            #[prost(string, repeated, tag = "7")]
267            pub relations: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
268        }
269        /// Nested message and enum types in `Link`.
270        pub mod link {
271            #[derive(
272                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
273            )]
274            #[repr(i32)]
275            pub enum IconSize {
276                SizeNone = 0,
277                SizeSmall = 1,
278                SizeMedium = 2,
279            }
280            impl IconSize {
281                /// String value of the enum field names used in the ProtoBuf definition.
282                ///
283                /// The values are not transformed in any way and thus are considered stable
284                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
285                pub fn as_str_name(&self) -> &'static str {
286                    match self {
287                        Self::SizeNone => "SizeNone",
288                        Self::SizeSmall => "SizeSmall",
289                        Self::SizeMedium => "SizeMedium",
290                    }
291                }
292                /// Creates an enum from field names used in the ProtoBuf definition.
293                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
294                    match value {
295                        "SizeNone" => Some(Self::SizeNone),
296                        "SizeSmall" => Some(Self::SizeSmall),
297                        "SizeMedium" => Some(Self::SizeMedium),
298                        _ => None,
299                    }
300                }
301            }
302            #[derive(
303                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
304            )]
305            #[repr(i32)]
306            pub enum Style {
307                Page = 0,
308                Dataview = 1,
309                Dashboard = 2,
310                /// ...
311                Archive = 3,
312            }
313            impl Style {
314                /// String value of the enum field names used in the ProtoBuf definition.
315                ///
316                /// The values are not transformed in any way and thus are considered stable
317                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
318                pub fn as_str_name(&self) -> &'static str {
319                    match self {
320                        Self::Page => "Page",
321                        Self::Dataview => "Dataview",
322                        Self::Dashboard => "Dashboard",
323                        Self::Archive => "Archive",
324                    }
325                }
326                /// Creates an enum from field names used in the ProtoBuf definition.
327                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
328                    match value {
329                        "Page" => Some(Self::Page),
330                        "Dataview" => Some(Self::Dataview),
331                        "Dashboard" => Some(Self::Dashboard),
332                        "Archive" => Some(Self::Archive),
333                        _ => None,
334                    }
335                }
336            }
337            #[derive(
338                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
339            )]
340            #[repr(i32)]
341            pub enum Description {
342                None = 0,
343                Added = 1,
344                Content = 2,
345            }
346            impl Description {
347                /// String value of the enum field names used in the ProtoBuf definition.
348                ///
349                /// The values are not transformed in any way and thus are considered stable
350                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
351                pub fn as_str_name(&self) -> &'static str {
352                    match self {
353                        Self::None => "None",
354                        Self::Added => "Added",
355                        Self::Content => "Content",
356                    }
357                }
358                /// Creates an enum from field names used in the ProtoBuf definition.
359                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
360                    match value {
361                        "None" => Some(Self::None),
362                        "Added" => Some(Self::Added),
363                        "Content" => Some(Self::Content),
364                        _ => None,
365                    }
366                }
367            }
368            #[derive(
369                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
370            )]
371            #[repr(i32)]
372            pub enum CardStyle {
373                Text = 0,
374                Card = 1,
375                Inline = 2,
376            }
377            impl CardStyle {
378                /// String value of the enum field names used in the ProtoBuf definition.
379                ///
380                /// The values are not transformed in any way and thus are considered stable
381                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
382                pub fn as_str_name(&self) -> &'static str {
383                    match self {
384                        Self::Text => "Text",
385                        Self::Card => "Card",
386                        Self::Inline => "Inline",
387                    }
388                }
389                /// Creates an enum from field names used in the ProtoBuf definition.
390                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
391                    match value {
392                        "Text" => Some(Self::Text),
393                        "Card" => Some(Self::Card),
394                        "Inline" => Some(Self::Inline),
395                        _ => None,
396                    }
397                }
398            }
399        }
400        /// Divider: block, that contains only one horizontal thin line
401        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
402        pub struct Div {
403            #[prost(enumeration = "div::Style", tag = "1")]
404            pub style: i32,
405        }
406        /// Nested message and enum types in `Div`.
407        pub mod div {
408            #[derive(
409                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
410            )]
411            #[repr(i32)]
412            pub enum Style {
413                Line = 0,
414                Dots = 1,
415            }
416            impl Style {
417                /// String value of the enum field names used in the ProtoBuf definition.
418                ///
419                /// The values are not transformed in any way and thus are considered stable
420                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
421                pub fn as_str_name(&self) -> &'static str {
422                    match self {
423                        Self::Line => "Line",
424                        Self::Dots => "Dots",
425                    }
426                }
427                /// Creates an enum from field names used in the ProtoBuf definition.
428                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
429                    match value {
430                        "Line" => Some(Self::Line),
431                        "Dots" => Some(Self::Dots),
432                        _ => None,
433                    }
434                }
435            }
436        }
437        /// Bookmark is to keep a web-link and to preview a content.
438        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
439        pub struct Bookmark {
440            #[prost(string, tag = "1")]
441            pub url: ::prost::alloc::string::String,
442            /// Deprecated. Get this data from the target object.
443            #[prost(string, tag = "2")]
444            pub title: ::prost::alloc::string::String,
445            /// Deprecated. Get this data from the target object.
446            #[prost(string, tag = "3")]
447            pub description: ::prost::alloc::string::String,
448            /// Deprecated. Get this data from the target object.
449            #[prost(string, tag = "4")]
450            pub image_hash: ::prost::alloc::string::String,
451            /// Deprecated. Get this data from the target object.
452            #[prost(string, tag = "5")]
453            pub favicon_hash: ::prost::alloc::string::String,
454            #[prost(enumeration = "super::super::link_preview::Type", tag = "6")]
455            pub r#type: i32,
456            #[prost(string, tag = "7")]
457            pub target_object_id: ::prost::alloc::string::String,
458            #[prost(enumeration = "bookmark::State", tag = "8")]
459            pub state: i32,
460        }
461        /// Nested message and enum types in `Bookmark`.
462        pub mod bookmark {
463            #[derive(
464                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
465            )]
466            #[repr(i32)]
467            pub enum State {
468                Empty = 0,
469                Fetching = 1,
470                Done = 2,
471                Error = 3,
472            }
473            impl State {
474                /// String value of the enum field names used in the ProtoBuf definition.
475                ///
476                /// The values are not transformed in any way and thus are considered stable
477                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
478                pub fn as_str_name(&self) -> &'static str {
479                    match self {
480                        Self::Empty => "Empty",
481                        Self::Fetching => "Fetching",
482                        Self::Done => "Done",
483                        Self::Error => "Error",
484                    }
485                }
486                /// Creates an enum from field names used in the ProtoBuf definition.
487                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
488                    match value {
489                        "Empty" => Some(Self::Empty),
490                        "Fetching" => Some(Self::Fetching),
491                        "Done" => Some(Self::Done),
492                        "Error" => Some(Self::Error),
493                        _ => None,
494                    }
495                }
496            }
497        }
498        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
499        pub struct Icon {
500            #[prost(string, tag = "1")]
501            pub name: ::prost::alloc::string::String,
502        }
503        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
504        pub struct FeaturedRelations {}
505        #[derive(Clone, PartialEq, ::prost::Message)]
506        pub struct Text {
507            #[prost(string, tag = "1")]
508            pub text: ::prost::alloc::string::String,
509            #[prost(enumeration = "text::Style", tag = "2")]
510            pub style: i32,
511            /// list of marks to apply to the text
512            #[prost(message, optional, tag = "3")]
513            pub marks: ::core::option::Option<text::Marks>,
514            #[prost(bool, tag = "4")]
515            pub checked: bool,
516            #[prost(string, tag = "5")]
517            pub color: ::prost::alloc::string::String,
518            /// used with style Callout
519            #[prost(string, tag = "6")]
520            pub icon_emoji: ::prost::alloc::string::String,
521            /// in case both image and emoji are set, image should has a priority in the UI
522            #[prost(string, tag = "7")]
523            pub icon_image: ::prost::alloc::string::String,
524        }
525        /// Nested message and enum types in `Text`.
526        pub mod text {
527            #[derive(Clone, PartialEq, ::prost::Message)]
528            pub struct Marks {
529                #[prost(message, repeated, tag = "1")]
530                pub marks: ::prost::alloc::vec::Vec<Mark>,
531            }
532            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
533            pub struct Mark {
534                /// range of symbols to apply this mark. From(symbol) To(symbol)
535                #[prost(message, optional, tag = "1")]
536                pub range: ::core::option::Option<super::super::super::Range>,
537                #[prost(enumeration = "mark::Type", tag = "2")]
538                pub r#type: i32,
539                /// link, color, etc
540                #[prost(string, tag = "3")]
541                pub param: ::prost::alloc::string::String,
542            }
543            /// Nested message and enum types in `Mark`.
544            pub mod mark {
545                #[derive(
546                    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
547                )]
548                #[repr(i32)]
549                pub enum Type {
550                    Strikethrough = 0,
551                    Keyboard = 1,
552                    Italic = 2,
553                    Bold = 3,
554                    Underscored = 4,
555                    Link = 5,
556                    TextColor = 6,
557                    BackgroundColor = 7,
558                    Mention = 8,
559                    Emoji = 9,
560                    Object = 10,
561                }
562                impl Type {
563                    /// String value of the enum field names used in the ProtoBuf definition.
564                    ///
565                    /// The values are not transformed in any way and thus are considered stable
566                    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
567                    pub fn as_str_name(&self) -> &'static str {
568                        match self {
569                            Self::Strikethrough => "Strikethrough",
570                            Self::Keyboard => "Keyboard",
571                            Self::Italic => "Italic",
572                            Self::Bold => "Bold",
573                            Self::Underscored => "Underscored",
574                            Self::Link => "Link",
575                            Self::TextColor => "TextColor",
576                            Self::BackgroundColor => "BackgroundColor",
577                            Self::Mention => "Mention",
578                            Self::Emoji => "Emoji",
579                            Self::Object => "Object",
580                        }
581                    }
582                    /// Creates an enum from field names used in the ProtoBuf definition.
583                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
584                        match value {
585                            "Strikethrough" => Some(Self::Strikethrough),
586                            "Keyboard" => Some(Self::Keyboard),
587                            "Italic" => Some(Self::Italic),
588                            "Bold" => Some(Self::Bold),
589                            "Underscored" => Some(Self::Underscored),
590                            "Link" => Some(Self::Link),
591                            "TextColor" => Some(Self::TextColor),
592                            "BackgroundColor" => Some(Self::BackgroundColor),
593                            "Mention" => Some(Self::Mention),
594                            "Emoji" => Some(Self::Emoji),
595                            "Object" => Some(Self::Object),
596                            _ => None,
597                        }
598                    }
599                }
600            }
601            #[derive(
602                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
603            )]
604            #[repr(i32)]
605            pub enum Style {
606                Paragraph = 0,
607                Header1 = 1,
608                Header2 = 2,
609                Header3 = 3,
610                /// deprecated
611                Header4 = 4,
612                Quote = 5,
613                Code = 6,
614                /// currently only one block of this style can exists on a page
615                Title = 7,
616                Checkbox = 8,
617                Marked = 9,
618                Numbered = 10,
619                Toggle = 11,
620                /// currently only one block of this style can exists on a page
621                Description = 12,
622                Callout = 13,
623                ToggleHeader1 = 14,
624                ToggleHeader2 = 15,
625                ToggleHeader3 = 16,
626            }
627            impl Style {
628                /// String value of the enum field names used in the ProtoBuf definition.
629                ///
630                /// The values are not transformed in any way and thus are considered stable
631                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
632                pub fn as_str_name(&self) -> &'static str {
633                    match self {
634                        Self::Paragraph => "Paragraph",
635                        Self::Header1 => "Header1",
636                        Self::Header2 => "Header2",
637                        Self::Header3 => "Header3",
638                        Self::Header4 => "Header4",
639                        Self::Quote => "Quote",
640                        Self::Code => "Code",
641                        Self::Title => "Title",
642                        Self::Checkbox => "Checkbox",
643                        Self::Marked => "Marked",
644                        Self::Numbered => "Numbered",
645                        Self::Toggle => "Toggle",
646                        Self::Description => "Description",
647                        Self::Callout => "Callout",
648                        Self::ToggleHeader1 => "ToggleHeader1",
649                        Self::ToggleHeader2 => "ToggleHeader2",
650                        Self::ToggleHeader3 => "ToggleHeader3",
651                    }
652                }
653                /// Creates an enum from field names used in the ProtoBuf definition.
654                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
655                    match value {
656                        "Paragraph" => Some(Self::Paragraph),
657                        "Header1" => Some(Self::Header1),
658                        "Header2" => Some(Self::Header2),
659                        "Header3" => Some(Self::Header3),
660                        "Header4" => Some(Self::Header4),
661                        "Quote" => Some(Self::Quote),
662                        "Code" => Some(Self::Code),
663                        "Title" => Some(Self::Title),
664                        "Checkbox" => Some(Self::Checkbox),
665                        "Marked" => Some(Self::Marked),
666                        "Numbered" => Some(Self::Numbered),
667                        "Toggle" => Some(Self::Toggle),
668                        "Description" => Some(Self::Description),
669                        "Callout" => Some(Self::Callout),
670                        "ToggleHeader1" => Some(Self::ToggleHeader1),
671                        "ToggleHeader2" => Some(Self::ToggleHeader2),
672                        "ToggleHeader3" => Some(Self::ToggleHeader3),
673                        _ => None,
674                    }
675                }
676            }
677        }
678        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
679        pub struct File {
680            #[prost(string, tag = "1")]
681            pub hash: ::prost::alloc::string::String,
682            #[prost(string, tag = "2")]
683            pub name: ::prost::alloc::string::String,
684            #[prost(enumeration = "file::Type", tag = "3")]
685            pub r#type: i32,
686            #[prost(string, tag = "4")]
687            pub mime: ::prost::alloc::string::String,
688            #[prost(int64, tag = "5")]
689            pub size: i64,
690            #[prost(int64, tag = "6")]
691            pub added_at: i64,
692            #[prost(string, tag = "9")]
693            pub target_object_id: ::prost::alloc::string::String,
694            #[prost(enumeration = "file::State", tag = "7")]
695            pub state: i32,
696            #[prost(enumeration = "file::Style", tag = "8")]
697            pub style: i32,
698        }
699        /// Nested message and enum types in `File`.
700        pub mod file {
701            #[derive(
702                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
703            )]
704            #[repr(i32)]
705            pub enum Type {
706                None = 0,
707                File = 1,
708                Image = 2,
709                Video = 3,
710                Audio = 4,
711                Pdf = 5,
712            }
713            impl Type {
714                /// String value of the enum field names used in the ProtoBuf definition.
715                ///
716                /// The values are not transformed in any way and thus are considered stable
717                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
718                pub fn as_str_name(&self) -> &'static str {
719                    match self {
720                        Self::None => "None",
721                        Self::File => "File",
722                        Self::Image => "Image",
723                        Self::Video => "Video",
724                        Self::Audio => "Audio",
725                        Self::Pdf => "PDF",
726                    }
727                }
728                /// Creates an enum from field names used in the ProtoBuf definition.
729                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
730                    match value {
731                        "None" => Some(Self::None),
732                        "File" => Some(Self::File),
733                        "Image" => Some(Self::Image),
734                        "Video" => Some(Self::Video),
735                        "Audio" => Some(Self::Audio),
736                        "PDF" => Some(Self::Pdf),
737                        _ => None,
738                    }
739                }
740            }
741            #[derive(
742                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
743            )]
744            #[repr(i32)]
745            pub enum Style {
746                /// all types expect File and None has Embed style by default
747                Auto = 0,
748                Link = 1,
749                Embed = 2,
750            }
751            impl Style {
752                /// String value of the enum field names used in the ProtoBuf definition.
753                ///
754                /// The values are not transformed in any way and thus are considered stable
755                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
756                pub fn as_str_name(&self) -> &'static str {
757                    match self {
758                        Self::Auto => "Auto",
759                        Self::Link => "Link",
760                        Self::Embed => "Embed",
761                    }
762                }
763                /// Creates an enum from field names used in the ProtoBuf definition.
764                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
765                    match value {
766                        "Auto" => Some(Self::Auto),
767                        "Link" => Some(Self::Link),
768                        "Embed" => Some(Self::Embed),
769                        _ => None,
770                    }
771                }
772            }
773            #[derive(
774                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
775            )]
776            #[repr(i32)]
777            pub enum State {
778                /// There is no file and preview, it's an empty block, that waits files.
779                Empty = 0,
780                /// There is still no file/preview, but file already uploading
781                Uploading = 1,
782                /// File and preview downloaded
783                Done = 2,
784                /// Error while uploading
785                Error = 3,
786            }
787            impl State {
788                /// String value of the enum field names used in the ProtoBuf definition.
789                ///
790                /// The values are not transformed in any way and thus are considered stable
791                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
792                pub fn as_str_name(&self) -> &'static str {
793                    match self {
794                        Self::Empty => "Empty",
795                        Self::Uploading => "Uploading",
796                        Self::Done => "Done",
797                        Self::Error => "Error",
798                    }
799                }
800                /// Creates an enum from field names used in the ProtoBuf definition.
801                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
802                    match value {
803                        "Empty" => Some(Self::Empty),
804                        "Uploading" => Some(Self::Uploading),
805                        "Done" => Some(Self::Done),
806                        "Error" => Some(Self::Error),
807                        _ => None,
808                    }
809                }
810            }
811        }
812        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
813        pub struct Smartblock {}
814        #[derive(Clone, PartialEq, ::prost::Message)]
815        pub struct Dataview {
816            /// can be set for detached(without TargetObjectId) inline sets
817            #[prost(string, repeated, tag = "1")]
818            pub source: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
819            #[prost(message, repeated, tag = "2")]
820            pub views: ::prost::alloc::vec::Vec<dataview::View>,
821            /// do not generate changes for this field
822            #[prost(string, tag = "3")]
823            pub active_view: ::prost::alloc::string::String,
824            /// deprecated
825            #[prost(message, repeated, tag = "4")]
826            pub relations: ::prost::alloc::vec::Vec<super::super::Relation>,
827            #[prost(message, repeated, tag = "12")]
828            pub group_orders: ::prost::alloc::vec::Vec<dataview::GroupOrder>,
829            #[prost(message, repeated, tag = "13")]
830            pub object_orders: ::prost::alloc::vec::Vec<dataview::ObjectOrder>,
831            #[prost(message, repeated, tag = "5")]
832            pub relation_links: ::prost::alloc::vec::Vec<super::super::RelationLink>,
833            /// empty for original set/collection objects and for detached inline sets
834            #[prost(string, tag = "6")]
835            pub target_object_id: ::prost::alloc::string::String,
836            #[prost(bool, tag = "14")]
837            pub is_collection: bool,
838        }
839        /// Nested message and enum types in `Dataview`.
840        pub mod dataview {
841            #[derive(Clone, PartialEq, ::prost::Message)]
842            pub struct View {
843                #[prost(string, tag = "1")]
844                pub id: ::prost::alloc::string::String,
845                #[prost(enumeration = "view::Type", tag = "2")]
846                pub r#type: i32,
847                #[prost(string, tag = "3")]
848                pub name: ::prost::alloc::string::String,
849                #[prost(message, repeated, tag = "4")]
850                pub sorts: ::prost::alloc::vec::Vec<Sort>,
851                #[prost(message, repeated, tag = "5")]
852                pub filters: ::prost::alloc::vec::Vec<Filter>,
853                /// relations fields/columns options, also used to provide the order
854                #[prost(message, repeated, tag = "6")]
855                pub relations: ::prost::alloc::vec::Vec<Relation>,
856                /// Relation used for cover in gallery
857                #[prost(string, tag = "7")]
858                pub cover_relation_key: ::prost::alloc::string::String,
859                /// Hide icon near name
860                #[prost(bool, tag = "8")]
861                pub hide_icon: bool,
862                /// Gallery card size
863                #[prost(enumeration = "view::Size", tag = "9")]
864                pub card_size: i32,
865                /// Image fits container
866                #[prost(bool, tag = "10")]
867                pub cover_fit: bool,
868                /// Group view by this relationKey
869                #[prost(string, tag = "11")]
870                pub group_relation_key: ::prost::alloc::string::String,
871                /// Enable backgrounds in groups
872                #[prost(bool, tag = "12")]
873                pub group_background_colors: bool,
874                /// Limit of objects shown in widget
875                #[prost(int32, tag = "13")]
876                pub page_limit: i32,
877                /// Default template that is chosen for new object created within the view
878                #[prost(string, tag = "14")]
879                pub default_template_id: ::prost::alloc::string::String,
880                /// Default object type that is chosen for new object created within the view
881                #[prost(string, tag = "15")]
882                pub default_object_type_id: ::prost::alloc::string::String,
883                /// Group view by this relationKey
884                #[prost(string, tag = "16")]
885                pub end_relation_key: ::prost::alloc::string::String,
886                /// Wrap content in view
887                #[prost(bool, tag = "17")]
888                pub wrap_content: bool,
889                /// List view size setting
890                #[prost(enumeration = "view::ListSize", tag = "18")]
891                pub list_size: i32,
892            }
893            /// Nested message and enum types in `View`.
894            pub mod view {
895                #[derive(
896                    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
897                )]
898                #[repr(i32)]
899                pub enum Type {
900                    Table = 0,
901                    List = 1,
902                    Gallery = 2,
903                    Kanban = 3,
904                    Calendar = 4,
905                    Graph = 5,
906                }
907                impl Type {
908                    /// String value of the enum field names used in the ProtoBuf definition.
909                    ///
910                    /// The values are not transformed in any way and thus are considered stable
911                    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
912                    pub fn as_str_name(&self) -> &'static str {
913                        match self {
914                            Self::Table => "Table",
915                            Self::List => "List",
916                            Self::Gallery => "Gallery",
917                            Self::Kanban => "Kanban",
918                            Self::Calendar => "Calendar",
919                            Self::Graph => "Graph",
920                        }
921                    }
922                    /// Creates an enum from field names used in the ProtoBuf definition.
923                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
924                        match value {
925                            "Table" => Some(Self::Table),
926                            "List" => Some(Self::List),
927                            "Gallery" => Some(Self::Gallery),
928                            "Kanban" => Some(Self::Kanban),
929                            "Calendar" => Some(Self::Calendar),
930                            "Graph" => Some(Self::Graph),
931                            _ => None,
932                        }
933                    }
934                }
935                #[derive(
936                    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
937                )]
938                #[repr(i32)]
939                pub enum Size {
940                    Small = 0,
941                    Medium = 1,
942                    Large = 2,
943                }
944                impl Size {
945                    /// String value of the enum field names used in the ProtoBuf definition.
946                    ///
947                    /// The values are not transformed in any way and thus are considered stable
948                    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
949                    pub fn as_str_name(&self) -> &'static str {
950                        match self {
951                            Self::Small => "Small",
952                            Self::Medium => "Medium",
953                            Self::Large => "Large",
954                        }
955                    }
956                    /// Creates an enum from field names used in the ProtoBuf definition.
957                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
958                        match value {
959                            "Small" => Some(Self::Small),
960                            "Medium" => Some(Self::Medium),
961                            "Large" => Some(Self::Large),
962                            _ => None,
963                        }
964                    }
965                }
966                #[derive(
967                    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
968                )]
969                #[repr(i32)]
970                pub enum ListSize {
971                    /// Single-line display (default)
972                    Compact = 0,
973                    /// Two-line display with description
974                    Regular = 1,
975                }
976                impl ListSize {
977                    /// String value of the enum field names used in the ProtoBuf definition.
978                    ///
979                    /// The values are not transformed in any way and thus are considered stable
980                    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
981                    pub fn as_str_name(&self) -> &'static str {
982                        match self {
983                            Self::Compact => "Compact",
984                            Self::Regular => "Regular",
985                        }
986                    }
987                    /// Creates an enum from field names used in the ProtoBuf definition.
988                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
989                        match value {
990                            "Compact" => Some(Self::Compact),
991                            "Regular" => Some(Self::Regular),
992                            _ => None,
993                        }
994                    }
995                }
996            }
997            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
998            pub struct Relation {
999                #[prost(string, tag = "1")]
1000                pub key: ::prost::alloc::string::String,
1001                #[prost(bool, tag = "2")]
1002                pub is_visible: bool,
1003                /// the displayed column % calculated based on other visible relations
1004                #[prost(int32, tag = "3")]
1005                pub width: i32,
1006                /// bool isReadOnly = 4; // deprecated
1007                ///
1008                /// deprecated
1009                #[prost(bool, tag = "5")]
1010                pub date_include_time: bool,
1011                /// deprecated
1012                #[prost(enumeration = "relation::TimeFormat", tag = "6")]
1013                pub time_format: i32,
1014                /// deprecated
1015                #[prost(enumeration = "relation::DateFormat", tag = "7")]
1016                pub date_format: i32,
1017                #[prost(enumeration = "relation::FormulaType", tag = "8")]
1018                pub formula: i32,
1019                #[prost(enumeration = "super::super::Align", tag = "9")]
1020                pub align: i32,
1021            }
1022            /// Nested message and enum types in `Relation`.
1023            pub mod relation {
1024                #[derive(
1025                    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
1026                )]
1027                #[repr(i32)]
1028                pub enum DateFormat {
1029                    /// Jul 30, 2020
1030                    MonthAbbrBeforeDay = 0,
1031                    /// 30 Jul 2020
1032                    MonthAbbrAfterDay = 1,
1033                    /// 30/07/2020
1034                    Short = 2,
1035                    /// 07/30/2020
1036                    ShortUs = 3,
1037                    /// 2020-07-30
1038                    Iso = 4,
1039                }
1040                impl DateFormat {
1041                    /// String value of the enum field names used in the ProtoBuf definition.
1042                    ///
1043                    /// The values are not transformed in any way and thus are considered stable
1044                    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1045                    pub fn as_str_name(&self) -> &'static str {
1046                        match self {
1047                            Self::MonthAbbrBeforeDay => "MonthAbbrBeforeDay",
1048                            Self::MonthAbbrAfterDay => "MonthAbbrAfterDay",
1049                            Self::Short => "Short",
1050                            Self::ShortUs => "ShortUS",
1051                            Self::Iso => "ISO",
1052                        }
1053                    }
1054                    /// Creates an enum from field names used in the ProtoBuf definition.
1055                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1056                        match value {
1057                            "MonthAbbrBeforeDay" => Some(Self::MonthAbbrBeforeDay),
1058                            "MonthAbbrAfterDay" => Some(Self::MonthAbbrAfterDay),
1059                            "Short" => Some(Self::Short),
1060                            "ShortUS" => Some(Self::ShortUs),
1061                            "ISO" => Some(Self::Iso),
1062                            _ => None,
1063                        }
1064                    }
1065                }
1066                #[derive(
1067                    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
1068                )]
1069                #[repr(i32)]
1070                pub enum TimeFormat {
1071                    Format12 = 0,
1072                    Format24 = 1,
1073                }
1074                impl TimeFormat {
1075                    /// String value of the enum field names used in the ProtoBuf definition.
1076                    ///
1077                    /// The values are not transformed in any way and thus are considered stable
1078                    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1079                    pub fn as_str_name(&self) -> &'static str {
1080                        match self {
1081                            Self::Format12 => "Format12",
1082                            Self::Format24 => "Format24",
1083                        }
1084                    }
1085                    /// Creates an enum from field names used in the ProtoBuf definition.
1086                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1087                        match value {
1088                            "Format12" => Some(Self::Format12),
1089                            "Format24" => Some(Self::Format24),
1090                            _ => None,
1091                        }
1092                    }
1093                }
1094                #[derive(
1095                    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
1096                )]
1097                #[repr(i32)]
1098                pub enum FormulaType {
1099                    None = 0,
1100                    Count = 1,
1101                    CountValue = 2,
1102                    CountDistinct = 3,
1103                    CountEmpty = 4,
1104                    CountNotEmpty = 5,
1105                    PercentEmpty = 6,
1106                    PercentNotEmpty = 7,
1107                    MathSum = 8,
1108                    MathAverage = 9,
1109                    MathMedian = 10,
1110                    MathMin = 11,
1111                    MathMax = 12,
1112                    Range = 13,
1113                }
1114                impl FormulaType {
1115                    /// String value of the enum field names used in the ProtoBuf definition.
1116                    ///
1117                    /// The values are not transformed in any way and thus are considered stable
1118                    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1119                    pub fn as_str_name(&self) -> &'static str {
1120                        match self {
1121                            Self::None => "None",
1122                            Self::Count => "Count",
1123                            Self::CountValue => "CountValue",
1124                            Self::CountDistinct => "CountDistinct",
1125                            Self::CountEmpty => "CountEmpty",
1126                            Self::CountNotEmpty => "CountNotEmpty",
1127                            Self::PercentEmpty => "PercentEmpty",
1128                            Self::PercentNotEmpty => "PercentNotEmpty",
1129                            Self::MathSum => "MathSum",
1130                            Self::MathAverage => "MathAverage",
1131                            Self::MathMedian => "MathMedian",
1132                            Self::MathMin => "MathMin",
1133                            Self::MathMax => "MathMax",
1134                            Self::Range => "Range",
1135                        }
1136                    }
1137                    /// Creates an enum from field names used in the ProtoBuf definition.
1138                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1139                        match value {
1140                            "None" => Some(Self::None),
1141                            "Count" => Some(Self::Count),
1142                            "CountValue" => Some(Self::CountValue),
1143                            "CountDistinct" => Some(Self::CountDistinct),
1144                            "CountEmpty" => Some(Self::CountEmpty),
1145                            "CountNotEmpty" => Some(Self::CountNotEmpty),
1146                            "PercentEmpty" => Some(Self::PercentEmpty),
1147                            "PercentNotEmpty" => Some(Self::PercentNotEmpty),
1148                            "MathSum" => Some(Self::MathSum),
1149                            "MathAverage" => Some(Self::MathAverage),
1150                            "MathMedian" => Some(Self::MathMedian),
1151                            "MathMin" => Some(Self::MathMin),
1152                            "MathMax" => Some(Self::MathMax),
1153                            "Range" => Some(Self::Range),
1154                            _ => None,
1155                        }
1156                    }
1157                }
1158            }
1159            #[derive(Clone, PartialEq, ::prost::Message)]
1160            pub struct Sort {
1161                #[prost(string, tag = "1")]
1162                pub relation_key: ::prost::alloc::string::String,
1163                #[prost(enumeration = "sort::Type", tag = "2")]
1164                pub r#type: i32,
1165                #[prost(message, repeated, tag = "3")]
1166                pub custom_order: ::prost::alloc::vec::Vec<::prost_types::Value>,
1167                #[prost(enumeration = "super::super::super::RelationFormat", tag = "4")]
1168                pub format: i32,
1169                #[prost(bool, tag = "5")]
1170                pub include_time: bool,
1171                #[prost(string, tag = "6")]
1172                pub id: ::prost::alloc::string::String,
1173                #[prost(enumeration = "sort::EmptyType", tag = "7")]
1174                pub empty_placement: i32,
1175                #[prost(bool, tag = "8")]
1176                pub no_collate: bool,
1177            }
1178            /// Nested message and enum types in `Sort`.
1179            pub mod sort {
1180                #[derive(
1181                    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
1182                )]
1183                #[repr(i32)]
1184                pub enum Type {
1185                    Asc = 0,
1186                    Desc = 1,
1187                    Custom = 2,
1188                }
1189                impl Type {
1190                    /// String value of the enum field names used in the ProtoBuf definition.
1191                    ///
1192                    /// The values are not transformed in any way and thus are considered stable
1193                    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1194                    pub fn as_str_name(&self) -> &'static str {
1195                        match self {
1196                            Self::Asc => "Asc",
1197                            Self::Desc => "Desc",
1198                            Self::Custom => "Custom",
1199                        }
1200                    }
1201                    /// Creates an enum from field names used in the ProtoBuf definition.
1202                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1203                        match value {
1204                            "Asc" => Some(Self::Asc),
1205                            "Desc" => Some(Self::Desc),
1206                            "Custom" => Some(Self::Custom),
1207                            _ => None,
1208                        }
1209                    }
1210                }
1211                #[derive(
1212                    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
1213                )]
1214                #[repr(i32)]
1215                pub enum EmptyType {
1216                    NotSpecified = 0,
1217                    Start = 1,
1218                    End = 2,
1219                }
1220                impl EmptyType {
1221                    /// String value of the enum field names used in the ProtoBuf definition.
1222                    ///
1223                    /// The values are not transformed in any way and thus are considered stable
1224                    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1225                    pub fn as_str_name(&self) -> &'static str {
1226                        match self {
1227                            Self::NotSpecified => "NotSpecified",
1228                            Self::Start => "Start",
1229                            Self::End => "End",
1230                        }
1231                    }
1232                    /// Creates an enum from field names used in the ProtoBuf definition.
1233                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1234                        match value {
1235                            "NotSpecified" => Some(Self::NotSpecified),
1236                            "Start" => Some(Self::Start),
1237                            "End" => Some(Self::End),
1238                            _ => None,
1239                        }
1240                    }
1241                }
1242            }
1243            #[derive(Clone, PartialEq, ::prost::Message)]
1244            pub struct Filter {
1245                #[prost(string, tag = "9")]
1246                pub id: ::prost::alloc::string::String,
1247                /// looks not applicable?
1248                #[prost(enumeration = "filter::Operator", tag = "1")]
1249                pub operator: i32,
1250                #[prost(string, tag = "2")]
1251                pub relation_key: ::prost::alloc::string::String,
1252                #[prost(string, tag = "5")]
1253                pub relation_property: ::prost::alloc::string::String,
1254                #[prost(enumeration = "filter::Condition", tag = "3")]
1255                pub condition: i32,
1256                #[prost(message, optional, tag = "4")]
1257                pub value: ::core::option::Option<::prost_types::Value>,
1258                #[prost(enumeration = "filter::QuickOption", tag = "6")]
1259                pub quick_option: i32,
1260                #[prost(enumeration = "super::super::super::RelationFormat", tag = "7")]
1261                pub format: i32,
1262                #[prost(bool, tag = "8")]
1263                pub include_time: bool,
1264                #[prost(message, repeated, tag = "10")]
1265                pub nested_filters: ::prost::alloc::vec::Vec<Filter>,
1266            }
1267            /// Nested message and enum types in `Filter`.
1268            pub mod filter {
1269                #[derive(
1270                    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
1271                )]
1272                #[repr(i32)]
1273                pub enum Operator {
1274                    No = 0,
1275                    Or = 1,
1276                    And = 2,
1277                }
1278                impl Operator {
1279                    /// String value of the enum field names used in the ProtoBuf definition.
1280                    ///
1281                    /// The values are not transformed in any way and thus are considered stable
1282                    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1283                    pub fn as_str_name(&self) -> &'static str {
1284                        match self {
1285                            Self::No => "No",
1286                            Self::Or => "Or",
1287                            Self::And => "And",
1288                        }
1289                    }
1290                    /// Creates an enum from field names used in the ProtoBuf definition.
1291                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1292                        match value {
1293                            "No" => Some(Self::No),
1294                            "Or" => Some(Self::Or),
1295                            "And" => Some(Self::And),
1296                            _ => None,
1297                        }
1298                    }
1299                }
1300                #[derive(
1301                    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
1302                )]
1303                #[repr(i32)]
1304                pub enum Condition {
1305                    None = 0,
1306                    Equal = 1,
1307                    NotEqual = 2,
1308                    Greater = 3,
1309                    Less = 4,
1310                    GreaterOrEqual = 5,
1311                    LessOrEqual = 6,
1312                    Like = 7,
1313                    NotLike = 8,
1314                    /// "at least one value(from the provided list) is IN"
1315                    In = 9,
1316                    /// "none of provided values are IN"
1317                    NotIn = 10,
1318                    Empty = 11,
1319                    NotEmpty = 12,
1320                    AllIn = 13,
1321                    NotAllIn = 14,
1322                    ExactIn = 15,
1323                    NotExactIn = 16,
1324                    Exists = 17,
1325                }
1326                impl Condition {
1327                    /// String value of the enum field names used in the ProtoBuf definition.
1328                    ///
1329                    /// The values are not transformed in any way and thus are considered stable
1330                    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1331                    pub fn as_str_name(&self) -> &'static str {
1332                        match self {
1333                            Self::None => "None",
1334                            Self::Equal => "Equal",
1335                            Self::NotEqual => "NotEqual",
1336                            Self::Greater => "Greater",
1337                            Self::Less => "Less",
1338                            Self::GreaterOrEqual => "GreaterOrEqual",
1339                            Self::LessOrEqual => "LessOrEqual",
1340                            Self::Like => "Like",
1341                            Self::NotLike => "NotLike",
1342                            Self::In => "In",
1343                            Self::NotIn => "NotIn",
1344                            Self::Empty => "Empty",
1345                            Self::NotEmpty => "NotEmpty",
1346                            Self::AllIn => "AllIn",
1347                            Self::NotAllIn => "NotAllIn",
1348                            Self::ExactIn => "ExactIn",
1349                            Self::NotExactIn => "NotExactIn",
1350                            Self::Exists => "Exists",
1351                        }
1352                    }
1353                    /// Creates an enum from field names used in the ProtoBuf definition.
1354                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1355                        match value {
1356                            "None" => Some(Self::None),
1357                            "Equal" => Some(Self::Equal),
1358                            "NotEqual" => Some(Self::NotEqual),
1359                            "Greater" => Some(Self::Greater),
1360                            "Less" => Some(Self::Less),
1361                            "GreaterOrEqual" => Some(Self::GreaterOrEqual),
1362                            "LessOrEqual" => Some(Self::LessOrEqual),
1363                            "Like" => Some(Self::Like),
1364                            "NotLike" => Some(Self::NotLike),
1365                            "In" => Some(Self::In),
1366                            "NotIn" => Some(Self::NotIn),
1367                            "Empty" => Some(Self::Empty),
1368                            "NotEmpty" => Some(Self::NotEmpty),
1369                            "AllIn" => Some(Self::AllIn),
1370                            "NotAllIn" => Some(Self::NotAllIn),
1371                            "ExactIn" => Some(Self::ExactIn),
1372                            "NotExactIn" => Some(Self::NotExactIn),
1373                            "Exists" => Some(Self::Exists),
1374                            _ => None,
1375                        }
1376                    }
1377                }
1378                #[derive(
1379                    Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
1380                )]
1381                #[repr(i32)]
1382                pub enum QuickOption {
1383                    ExactDate = 0,
1384                    Yesterday = 1,
1385                    Today = 2,
1386                    Tomorrow = 3,
1387                    LastWeek = 4,
1388                    CurrentWeek = 5,
1389                    NextWeek = 6,
1390                    LastMonth = 7,
1391                    CurrentMonth = 8,
1392                    NextMonth = 9,
1393                    NumberOfDaysAgo = 10,
1394                    NumberOfDaysNow = 11,
1395                    LastYear = 12,
1396                    CurrentYear = 13,
1397                    NextYear = 14,
1398                }
1399                impl QuickOption {
1400                    /// String value of the enum field names used in the ProtoBuf definition.
1401                    ///
1402                    /// The values are not transformed in any way and thus are considered stable
1403                    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1404                    pub fn as_str_name(&self) -> &'static str {
1405                        match self {
1406                            Self::ExactDate => "ExactDate",
1407                            Self::Yesterday => "Yesterday",
1408                            Self::Today => "Today",
1409                            Self::Tomorrow => "Tomorrow",
1410                            Self::LastWeek => "LastWeek",
1411                            Self::CurrentWeek => "CurrentWeek",
1412                            Self::NextWeek => "NextWeek",
1413                            Self::LastMonth => "LastMonth",
1414                            Self::CurrentMonth => "CurrentMonth",
1415                            Self::NextMonth => "NextMonth",
1416                            Self::NumberOfDaysAgo => "NumberOfDaysAgo",
1417                            Self::NumberOfDaysNow => "NumberOfDaysNow",
1418                            Self::LastYear => "LastYear",
1419                            Self::CurrentYear => "CurrentYear",
1420                            Self::NextYear => "NextYear",
1421                        }
1422                    }
1423                    /// Creates an enum from field names used in the ProtoBuf definition.
1424                    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1425                        match value {
1426                            "ExactDate" => Some(Self::ExactDate),
1427                            "Yesterday" => Some(Self::Yesterday),
1428                            "Today" => Some(Self::Today),
1429                            "Tomorrow" => Some(Self::Tomorrow),
1430                            "LastWeek" => Some(Self::LastWeek),
1431                            "CurrentWeek" => Some(Self::CurrentWeek),
1432                            "NextWeek" => Some(Self::NextWeek),
1433                            "LastMonth" => Some(Self::LastMonth),
1434                            "CurrentMonth" => Some(Self::CurrentMonth),
1435                            "NextMonth" => Some(Self::NextMonth),
1436                            "NumberOfDaysAgo" => Some(Self::NumberOfDaysAgo),
1437                            "NumberOfDaysNow" => Some(Self::NumberOfDaysNow),
1438                            "LastYear" => Some(Self::LastYear),
1439                            "CurrentYear" => Some(Self::CurrentYear),
1440                            "NextYear" => Some(Self::NextYear),
1441                            _ => None,
1442                        }
1443                    }
1444                }
1445            }
1446            #[derive(Clone, PartialEq, ::prost::Message)]
1447            pub struct GroupOrder {
1448                #[prost(string, tag = "1")]
1449                pub view_id: ::prost::alloc::string::String,
1450                #[prost(message, repeated, tag = "2")]
1451                pub view_groups: ::prost::alloc::vec::Vec<ViewGroup>,
1452            }
1453            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1454            pub struct ViewGroup {
1455                #[prost(string, tag = "1")]
1456                pub group_id: ::prost::alloc::string::String,
1457                #[prost(int32, tag = "2")]
1458                pub index: i32,
1459                #[prost(bool, tag = "3")]
1460                pub hidden: bool,
1461                #[prost(string, tag = "4")]
1462                pub background_color: ::prost::alloc::string::String,
1463            }
1464            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1465            pub struct ObjectOrder {
1466                #[prost(string, tag = "1")]
1467                pub view_id: ::prost::alloc::string::String,
1468                #[prost(string, tag = "2")]
1469                pub group_id: ::prost::alloc::string::String,
1470                #[prost(string, repeated, tag = "3")]
1471                pub object_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1472            }
1473            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1474            pub struct Group {
1475                #[prost(string, tag = "1")]
1476                pub id: ::prost::alloc::string::String,
1477                #[prost(oneof = "group::Value", tags = "2, 3, 4, 5")]
1478                pub value: ::core::option::Option<group::Value>,
1479            }
1480            /// Nested message and enum types in `Group`.
1481            pub mod group {
1482                #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
1483                pub enum Value {
1484                    #[prost(message, tag = "2")]
1485                    Status(super::Status),
1486                    #[prost(message, tag = "3")]
1487                    Tag(super::Tag),
1488                    #[prost(message, tag = "4")]
1489                    Checkbox(super::Checkbox),
1490                    #[prost(message, tag = "5")]
1491                    Date(super::Date),
1492                }
1493            }
1494            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1495            pub struct Status {
1496                #[prost(string, tag = "1")]
1497                pub id: ::prost::alloc::string::String,
1498            }
1499            #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1500            pub struct Tag {
1501                #[prost(string, repeated, tag = "1")]
1502                pub ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
1503            }
1504            #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1505            pub struct Checkbox {
1506                #[prost(bool, tag = "1")]
1507                pub checked: bool,
1508            }
1509            #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1510            pub struct Date {}
1511        }
1512        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1513        pub struct Relation {
1514            #[prost(string, tag = "1")]
1515            pub key: ::prost::alloc::string::String,
1516        }
1517        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1518        pub struct Latex {
1519            #[prost(string, tag = "1")]
1520            pub text: ::prost::alloc::string::String,
1521            #[prost(enumeration = "latex::Processor", tag = "2")]
1522            pub processor: i32,
1523        }
1524        /// Nested message and enum types in `Latex`.
1525        pub mod latex {
1526            #[derive(
1527                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
1528            )]
1529            #[repr(i32)]
1530            pub enum Processor {
1531                Latex = 0,
1532                Mermaid = 1,
1533                Chart = 2,
1534                Youtube = 3,
1535                Vimeo = 4,
1536                Soundcloud = 5,
1537                GoogleMaps = 6,
1538                Miro = 7,
1539                Figma = 8,
1540                Twitter = 9,
1541                OpenStreetMap = 10,
1542                Reddit = 11,
1543                Facebook = 12,
1544                Instagram = 13,
1545                Telegram = 14,
1546                GithubGist = 15,
1547                Codepen = 16,
1548                Bilibili = 17,
1549                Excalidraw = 18,
1550                Kroki = 19,
1551                Graphviz = 20,
1552                Sketchfab = 21,
1553                Image = 22,
1554                Drawio = 23,
1555                Spotify = 24,
1556            }
1557            impl Processor {
1558                /// String value of the enum field names used in the ProtoBuf definition.
1559                ///
1560                /// The values are not transformed in any way and thus are considered stable
1561                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1562                pub fn as_str_name(&self) -> &'static str {
1563                    match self {
1564                        Self::Latex => "Latex",
1565                        Self::Mermaid => "Mermaid",
1566                        Self::Chart => "Chart",
1567                        Self::Youtube => "Youtube",
1568                        Self::Vimeo => "Vimeo",
1569                        Self::Soundcloud => "Soundcloud",
1570                        Self::GoogleMaps => "GoogleMaps",
1571                        Self::Miro => "Miro",
1572                        Self::Figma => "Figma",
1573                        Self::Twitter => "Twitter",
1574                        Self::OpenStreetMap => "OpenStreetMap",
1575                        Self::Reddit => "Reddit",
1576                        Self::Facebook => "Facebook",
1577                        Self::Instagram => "Instagram",
1578                        Self::Telegram => "Telegram",
1579                        Self::GithubGist => "GithubGist",
1580                        Self::Codepen => "Codepen",
1581                        Self::Bilibili => "Bilibili",
1582                        Self::Excalidraw => "Excalidraw",
1583                        Self::Kroki => "Kroki",
1584                        Self::Graphviz => "Graphviz",
1585                        Self::Sketchfab => "Sketchfab",
1586                        Self::Image => "Image",
1587                        Self::Drawio => "Drawio",
1588                        Self::Spotify => "Spotify",
1589                    }
1590                }
1591                /// Creates an enum from field names used in the ProtoBuf definition.
1592                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1593                    match value {
1594                        "Latex" => Some(Self::Latex),
1595                        "Mermaid" => Some(Self::Mermaid),
1596                        "Chart" => Some(Self::Chart),
1597                        "Youtube" => Some(Self::Youtube),
1598                        "Vimeo" => Some(Self::Vimeo),
1599                        "Soundcloud" => Some(Self::Soundcloud),
1600                        "GoogleMaps" => Some(Self::GoogleMaps),
1601                        "Miro" => Some(Self::Miro),
1602                        "Figma" => Some(Self::Figma),
1603                        "Twitter" => Some(Self::Twitter),
1604                        "OpenStreetMap" => Some(Self::OpenStreetMap),
1605                        "Reddit" => Some(Self::Reddit),
1606                        "Facebook" => Some(Self::Facebook),
1607                        "Instagram" => Some(Self::Instagram),
1608                        "Telegram" => Some(Self::Telegram),
1609                        "GithubGist" => Some(Self::GithubGist),
1610                        "Codepen" => Some(Self::Codepen),
1611                        "Bilibili" => Some(Self::Bilibili),
1612                        "Excalidraw" => Some(Self::Excalidraw),
1613                        "Kroki" => Some(Self::Kroki),
1614                        "Graphviz" => Some(Self::Graphviz),
1615                        "Sketchfab" => Some(Self::Sketchfab),
1616                        "Image" => Some(Self::Image),
1617                        "Drawio" => Some(Self::Drawio),
1618                        "Spotify" => Some(Self::Spotify),
1619                        _ => None,
1620                    }
1621                }
1622            }
1623        }
1624        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1625        pub struct TableOfContents {}
1626        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1627        pub struct Table {}
1628        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1629        pub struct TableColumn {}
1630        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1631        pub struct TableRow {
1632            #[prost(bool, tag = "1")]
1633            pub is_header: bool,
1634        }
1635        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1636        pub struct Widget {
1637            #[prost(enumeration = "widget::Layout", tag = "1")]
1638            pub layout: i32,
1639            #[prost(int32, tag = "2")]
1640            pub limit: i32,
1641            #[prost(string, tag = "3")]
1642            pub view_id: ::prost::alloc::string::String,
1643            #[prost(bool, tag = "4")]
1644            pub auto_added: bool,
1645        }
1646        /// Nested message and enum types in `Widget`.
1647        pub mod widget {
1648            #[derive(
1649                Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
1650            )]
1651            #[repr(i32)]
1652            pub enum Layout {
1653                Link = 0,
1654                Tree = 1,
1655                List = 2,
1656                CompactList = 3,
1657                View = 4,
1658            }
1659            impl Layout {
1660                /// String value of the enum field names used in the ProtoBuf definition.
1661                ///
1662                /// The values are not transformed in any way and thus are considered stable
1663                /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1664                pub fn as_str_name(&self) -> &'static str {
1665                    match self {
1666                        Self::Link => "Link",
1667                        Self::Tree => "Tree",
1668                        Self::List => "List",
1669                        Self::CompactList => "CompactList",
1670                        Self::View => "View",
1671                    }
1672                }
1673                /// Creates an enum from field names used in the ProtoBuf definition.
1674                pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1675                    match value {
1676                        "Link" => Some(Self::Link),
1677                        "Tree" => Some(Self::Tree),
1678                        "List" => Some(Self::List),
1679                        "CompactList" => Some(Self::CompactList),
1680                        "View" => Some(Self::View),
1681                        _ => None,
1682                    }
1683                }
1684            }
1685        }
1686        #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1687        pub struct Chat {}
1688    }
1689    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1690    #[repr(i32)]
1691    pub enum Position {
1692        None = 0,
1693        /// above target block
1694        Top = 1,
1695        /// under target block
1696        Bottom = 2,
1697        /// to left of target block
1698        Left = 3,
1699        /// to right of target block
1700        Right = 4,
1701        /// inside target block, as last block
1702        Inner = 5,
1703        /// replace target block
1704        Replace = 6,
1705        /// inside target block, as first block
1706        InnerFirst = 7,
1707    }
1708    impl Position {
1709        /// String value of the enum field names used in the ProtoBuf definition.
1710        ///
1711        /// The values are not transformed in any way and thus are considered stable
1712        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1713        pub fn as_str_name(&self) -> &'static str {
1714            match self {
1715                Self::None => "None",
1716                Self::Top => "Top",
1717                Self::Bottom => "Bottom",
1718                Self::Left => "Left",
1719                Self::Right => "Right",
1720                Self::Inner => "Inner",
1721                Self::Replace => "Replace",
1722                Self::InnerFirst => "InnerFirst",
1723            }
1724        }
1725        /// Creates an enum from field names used in the ProtoBuf definition.
1726        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1727            match value {
1728                "None" => Some(Self::None),
1729                "Top" => Some(Self::Top),
1730                "Bottom" => Some(Self::Bottom),
1731                "Left" => Some(Self::Left),
1732                "Right" => Some(Self::Right),
1733                "Inner" => Some(Self::Inner),
1734                "Replace" => Some(Self::Replace),
1735                "InnerFirst" => Some(Self::InnerFirst),
1736                _ => None,
1737            }
1738        }
1739    }
1740    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1741    #[repr(i32)]
1742    pub enum Align {
1743        Left = 0,
1744        Center = 1,
1745        Right = 2,
1746        Justify = 3,
1747    }
1748    impl Align {
1749        /// String value of the enum field names used in the ProtoBuf definition.
1750        ///
1751        /// The values are not transformed in any way and thus are considered stable
1752        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1753        pub fn as_str_name(&self) -> &'static str {
1754            match self {
1755                Self::Left => "AlignLeft",
1756                Self::Center => "AlignCenter",
1757                Self::Right => "AlignRight",
1758                Self::Justify => "AlignJustify",
1759            }
1760        }
1761        /// Creates an enum from field names used in the ProtoBuf definition.
1762        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1763            match value {
1764                "AlignLeft" => Some(Self::Left),
1765                "AlignCenter" => Some(Self::Center),
1766                "AlignRight" => Some(Self::Right),
1767                "AlignJustify" => Some(Self::Justify),
1768                _ => None,
1769            }
1770        }
1771    }
1772    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
1773    #[repr(i32)]
1774    pub enum VerticalAlign {
1775        Top = 0,
1776        Middle = 1,
1777        Bottom = 2,
1778    }
1779    impl VerticalAlign {
1780        /// String value of the enum field names used in the ProtoBuf definition.
1781        ///
1782        /// The values are not transformed in any way and thus are considered stable
1783        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1784        pub fn as_str_name(&self) -> &'static str {
1785            match self {
1786                Self::Top => "VerticalAlignTop",
1787                Self::Middle => "VerticalAlignMiddle",
1788                Self::Bottom => "VerticalAlignBottom",
1789            }
1790        }
1791        /// Creates an enum from field names used in the ProtoBuf definition.
1792        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1793            match value {
1794                "VerticalAlignTop" => Some(Self::Top),
1795                "VerticalAlignMiddle" => Some(Self::Middle),
1796                "VerticalAlignBottom" => Some(Self::Bottom),
1797                _ => None,
1798            }
1799        }
1800    }
1801    #[derive(Clone, PartialEq, ::prost::Oneof)]
1802    pub enum ContentValue {
1803        #[prost(message, tag = "11")]
1804        Smartblock(content::Smartblock),
1805        #[prost(message, tag = "14")]
1806        Text(content::Text),
1807        #[prost(message, tag = "15")]
1808        File(content::File),
1809        #[prost(message, tag = "16")]
1810        Layout(content::Layout),
1811        #[prost(message, tag = "17")]
1812        Div(content::Div),
1813        #[prost(message, tag = "18")]
1814        Bookmark(content::Bookmark),
1815        #[prost(message, tag = "19")]
1816        Icon(content::Icon),
1817        #[prost(message, tag = "20")]
1818        Link(content::Link),
1819        #[prost(message, tag = "21")]
1820        Dataview(content::Dataview),
1821        #[prost(message, tag = "22")]
1822        Relation(content::Relation),
1823        #[prost(message, tag = "23")]
1824        FeaturedRelations(content::FeaturedRelations),
1825        #[prost(message, tag = "24")]
1826        Latex(content::Latex),
1827        #[prost(message, tag = "25")]
1828        TableOfContents(content::TableOfContents),
1829        #[prost(message, tag = "26")]
1830        Table(content::Table),
1831        #[prost(message, tag = "27")]
1832        TableColumn(content::TableColumn),
1833        #[prost(message, tag = "28")]
1834        TableRow(content::TableRow),
1835        #[prost(message, tag = "29")]
1836        Widget(content::Widget),
1837        #[prost(message, tag = "30")]
1838        Chat(content::Chat),
1839    }
1840}
1841/// Used to decode block meta only, without the content itself
1842#[derive(Clone, PartialEq, ::prost::Message)]
1843pub struct BlockMetaOnly {
1844    #[prost(string, tag = "1")]
1845    pub id: ::prost::alloc::string::String,
1846    #[prost(message, optional, tag = "2")]
1847    pub fields: ::core::option::Option<::prost_types::Struct>,
1848}
1849/// General purpose structure, uses in Mark.
1850#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1851pub struct Range {
1852    #[prost(int32, tag = "1")]
1853    pub from: i32,
1854    #[prost(int32, tag = "2")]
1855    pub to: i32,
1856}
1857/// *
1858///
1859/// Contains basic information about a user account
1860#[derive(Clone, PartialEq, ::prost::Message)]
1861pub struct Account {
1862    /// User's thread id
1863    #[prost(string, tag = "1")]
1864    pub id: ::prost::alloc::string::String,
1865    #[prost(message, optional, tag = "4")]
1866    pub config: ::core::option::Option<account::Config>,
1867    #[prost(message, optional, tag = "5")]
1868    pub status: ::core::option::Option<account::Status>,
1869    #[prost(message, optional, tag = "6")]
1870    pub info: ::core::option::Option<account::Info>,
1871}
1872/// Nested message and enum types in `Account`.
1873pub mod account {
1874    #[derive(Clone, PartialEq, ::prost::Message)]
1875    pub struct Config {
1876        #[prost(bool, tag = "1")]
1877        pub enable_dataview: bool,
1878        #[prost(bool, tag = "2")]
1879        pub enable_debug: bool,
1880        #[prost(bool, tag = "3")]
1881        pub enable_prerelease_channel: bool,
1882        #[prost(bool, tag = "4")]
1883        pub enable_spaces: bool,
1884        #[prost(message, optional, tag = "100")]
1885        pub extra: ::core::option::Option<::prost_types::Struct>,
1886    }
1887    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1888    pub struct Status {
1889        #[prost(enumeration = "StatusType", tag = "1")]
1890        pub status_type: i32,
1891        #[prost(int64, tag = "2")]
1892        pub deletion_date: i64,
1893    }
1894    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1895    pub struct Info {
1896        /// home dashboard block id
1897        #[prost(string, tag = "2")]
1898        pub home_object_id: ::prost::alloc::string::String,
1899        /// archive block id
1900        #[prost(string, tag = "3")]
1901        pub archive_object_id: ::prost::alloc::string::String,
1902        /// profile block id
1903        #[prost(string, tag = "4")]
1904        pub profile_object_id: ::prost::alloc::string::String,
1905        /// marketplace workspace id
1906        #[prost(string, tag = "11")]
1907        pub marketplace_workspace_id: ::prost::alloc::string::String,
1908        /// workspace object id. used for space-level chat
1909        #[prost(string, tag = "15")]
1910        pub workspace_object_id: ::prost::alloc::string::String,
1911        /// space-level chat if exists
1912        #[prost(string, tag = "16")]
1913        pub space_chat_id: ::prost::alloc::string::String,
1914        #[prost(string, tag = "8")]
1915        pub device_id: ::prost::alloc::string::String,
1916        /// the first created private space. It's filled only when account is created
1917        #[prost(string, tag = "9")]
1918        pub account_space_id: ::prost::alloc::string::String,
1919        #[prost(string, tag = "10")]
1920        pub widgets_id: ::prost::alloc::string::String,
1921        #[prost(string, tag = "13")]
1922        pub space_view_id: ::prost::alloc::string::String,
1923        #[prost(string, tag = "14")]
1924        pub tech_space_id: ::prost::alloc::string::String,
1925        /// gateway url for fetching static files
1926        #[prost(string, tag = "101")]
1927        pub gateway_url: ::prost::alloc::string::String,
1928        /// path to local storage
1929        #[prost(string, tag = "103")]
1930        pub local_storage_path: ::prost::alloc::string::String,
1931        /// time zone from config
1932        #[prost(string, tag = "104")]
1933        pub time_zone: ::prost::alloc::string::String,
1934        #[prost(string, tag = "105")]
1935        pub analytics_id: ::prost::alloc::string::String,
1936        /// network id to which anytype is connected
1937        #[prost(string, tag = "106")]
1938        pub network_id: ::prost::alloc::string::String,
1939        /// we have Any PK AND Ethereum PK derived from one seed phrase
1940        #[prost(string, tag = "107")]
1941        pub ethereum_address: ::prost::alloc::string::String,
1942        /// symmetric key for encrypting profile metadata
1943        #[prost(string, tag = "108")]
1944        pub meta_data_key: ::prost::alloc::string::String,
1945    }
1946    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
1947    pub struct Auth {}
1948    /// Nested message and enum types in `Auth`.
1949    pub mod auth {
1950        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
1951        pub struct AppInfo {
1952            #[prost(string, tag = "1")]
1953            pub app_hash: ::prost::alloc::string::String,
1954            /// either from process or specified manually when creating
1955            #[prost(string, tag = "2")]
1956            pub app_name: ::prost::alloc::string::String,
1957            #[prost(string, tag = "4")]
1958            pub app_key: ::prost::alloc::string::String,
1959            #[prost(int64, tag = "5")]
1960            pub created_at: i64,
1961            #[prost(int64, tag = "6")]
1962            pub expire_at: i64,
1963            #[prost(enumeration = "LocalApiScope", tag = "7")]
1964            pub scope: i32,
1965            #[prost(bool, tag = "8")]
1966            pub is_active: bool,
1967        }
1968        #[derive(
1969            Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
1970        )]
1971        #[repr(i32)]
1972        pub enum LocalApiScope {
1973            /// Used in WebClipper; AccountSelect(to be deprecated), ObjectSearch, ObjectShow, ObjectCreate, ObjectCreateFromURL, BlockPreview, BlockPaste, BroadcastPayloadEvent
1974            Limited = 0,
1975            /// JSON API only, no direct grpc api calls allowed
1976            JsonApi = 1,
1977            /// Full access, not available via LocalLink
1978            Full = 2,
1979        }
1980        impl LocalApiScope {
1981            /// String value of the enum field names used in the ProtoBuf definition.
1982            ///
1983            /// The values are not transformed in any way and thus are considered stable
1984            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
1985            pub fn as_str_name(&self) -> &'static str {
1986                match self {
1987                    Self::Limited => "Limited",
1988                    Self::JsonApi => "JsonAPI",
1989                    Self::Full => "Full",
1990                }
1991            }
1992            /// Creates an enum from field names used in the ProtoBuf definition.
1993            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
1994                match value {
1995                    "Limited" => Some(Self::Limited),
1996                    "JsonAPI" => Some(Self::JsonApi),
1997                    "Full" => Some(Self::Full),
1998                    _ => None,
1999                }
2000            }
2001        }
2002    }
2003    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2004    #[repr(i32)]
2005    pub enum StatusType {
2006        Active = 0,
2007        PendingDeletion = 1,
2008        StartedDeletion = 2,
2009        Deleted = 3,
2010    }
2011    impl StatusType {
2012        /// String value of the enum field names used in the ProtoBuf definition.
2013        ///
2014        /// The values are not transformed in any way and thus are considered stable
2015        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2016        pub fn as_str_name(&self) -> &'static str {
2017            match self {
2018                Self::Active => "Active",
2019                Self::PendingDeletion => "PendingDeletion",
2020                Self::StartedDeletion => "StartedDeletion",
2021                Self::Deleted => "Deleted",
2022            }
2023        }
2024        /// Creates an enum from field names used in the ProtoBuf definition.
2025        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2026            match value {
2027                "Active" => Some(Self::Active),
2028                "PendingDeletion" => Some(Self::PendingDeletion),
2029                "StartedDeletion" => Some(Self::StartedDeletion),
2030                "Deleted" => Some(Self::Deleted),
2031                _ => None,
2032            }
2033        }
2034    }
2035}
2036#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2037pub struct LinkPreview {
2038    #[prost(string, tag = "1")]
2039    pub url: ::prost::alloc::string::String,
2040    #[prost(string, tag = "2")]
2041    pub title: ::prost::alloc::string::String,
2042    #[prost(string, tag = "3")]
2043    pub description: ::prost::alloc::string::String,
2044    #[prost(string, tag = "4")]
2045    pub image_url: ::prost::alloc::string::String,
2046    #[prost(string, tag = "5")]
2047    pub favicon_url: ::prost::alloc::string::String,
2048    #[prost(enumeration = "link_preview::Type", tag = "6")]
2049    pub r#type: i32,
2050}
2051/// Nested message and enum types in `LinkPreview`.
2052pub mod link_preview {
2053    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2054    #[repr(i32)]
2055    pub enum Type {
2056        Unknown = 0,
2057        Page = 1,
2058        Image = 2,
2059        Text = 3,
2060    }
2061    impl Type {
2062        /// String value of the enum field names used in the ProtoBuf definition.
2063        ///
2064        /// The values are not transformed in any way and thus are considered stable
2065        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2066        pub fn as_str_name(&self) -> &'static str {
2067            match self {
2068                Self::Unknown => "Unknown",
2069                Self::Page => "Page",
2070                Self::Image => "Image",
2071                Self::Text => "Text",
2072            }
2073        }
2074        /// Creates an enum from field names used in the ProtoBuf definition.
2075        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2076            match value {
2077                "Unknown" => Some(Self::Unknown),
2078                "Page" => Some(Self::Page),
2079                "Image" => Some(Self::Image),
2080                "Text" => Some(Self::Text),
2081                _ => None,
2082            }
2083        }
2084    }
2085}
2086#[derive(Clone, PartialEq, ::prost::Message)]
2087pub struct Restrictions {
2088    #[prost(enumeration = "restrictions::ObjectRestriction", repeated, tag = "1")]
2089    pub object: ::prost::alloc::vec::Vec<i32>,
2090    #[prost(message, repeated, tag = "2")]
2091    pub dataview: ::prost::alloc::vec::Vec<restrictions::DataviewRestrictions>,
2092}
2093/// Nested message and enum types in `Restrictions`.
2094pub mod restrictions {
2095    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2096    pub struct DataviewRestrictions {
2097        #[prost(string, tag = "1")]
2098        pub block_id: ::prost::alloc::string::String,
2099        #[prost(enumeration = "DataviewRestriction", repeated, tag = "2")]
2100        pub restrictions: ::prost::alloc::vec::Vec<i32>,
2101    }
2102    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2103    #[repr(i32)]
2104    pub enum ObjectRestriction {
2105        None = 0,
2106        /// restricts delete
2107        Delete = 1,
2108        /// restricts work with relations
2109        Relations = 2,
2110        /// restricts work with blocks
2111        Blocks = 3,
2112        /// restricts work with details
2113        Details = 4,
2114        /// restricts type changing
2115        TypeChange = 5,
2116        /// restricts layout changing
2117        LayoutChange = 6,
2118        /// restricts template creation from this object
2119        Template = 7,
2120        /// restricts duplicate object
2121        Duplicate = 8,
2122        /// can be set only for types. Restricts creating objects of this type
2123        CreateObjectOfThisType = 9,
2124        /// object is not allowed to publish
2125        Publish = 10,
2126    }
2127    impl ObjectRestriction {
2128        /// String value of the enum field names used in the ProtoBuf definition.
2129        ///
2130        /// The values are not transformed in any way and thus are considered stable
2131        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2132        pub fn as_str_name(&self) -> &'static str {
2133            match self {
2134                Self::None => "None",
2135                Self::Delete => "Delete",
2136                Self::Relations => "Relations",
2137                Self::Blocks => "Blocks",
2138                Self::Details => "Details",
2139                Self::TypeChange => "TypeChange",
2140                Self::LayoutChange => "LayoutChange",
2141                Self::Template => "Template",
2142                Self::Duplicate => "Duplicate",
2143                Self::CreateObjectOfThisType => "CreateObjectOfThisType",
2144                Self::Publish => "Publish",
2145            }
2146        }
2147        /// Creates an enum from field names used in the ProtoBuf definition.
2148        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2149            match value {
2150                "None" => Some(Self::None),
2151                "Delete" => Some(Self::Delete),
2152                "Relations" => Some(Self::Relations),
2153                "Blocks" => Some(Self::Blocks),
2154                "Details" => Some(Self::Details),
2155                "TypeChange" => Some(Self::TypeChange),
2156                "LayoutChange" => Some(Self::LayoutChange),
2157                "Template" => Some(Self::Template),
2158                "Duplicate" => Some(Self::Duplicate),
2159                "CreateObjectOfThisType" => Some(Self::CreateObjectOfThisType),
2160                "Publish" => Some(Self::Publish),
2161                _ => None,
2162            }
2163        }
2164    }
2165    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2166    #[repr(i32)]
2167    pub enum DataviewRestriction {
2168        DvNone = 0,
2169        DvRelation = 1,
2170        DvCreateObject = 2,
2171        DvViews = 3,
2172    }
2173    impl DataviewRestriction {
2174        /// String value of the enum field names used in the ProtoBuf definition.
2175        ///
2176        /// The values are not transformed in any way and thus are considered stable
2177        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2178        pub fn as_str_name(&self) -> &'static str {
2179            match self {
2180                Self::DvNone => "DVNone",
2181                Self::DvRelation => "DVRelation",
2182                Self::DvCreateObject => "DVCreateObject",
2183                Self::DvViews => "DVViews",
2184            }
2185        }
2186        /// Creates an enum from field names used in the ProtoBuf definition.
2187        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2188            match value {
2189                "DVNone" => Some(Self::DvNone),
2190                "DVRelation" => Some(Self::DvRelation),
2191                "DVCreateObject" => Some(Self::DvCreateObject),
2192                "DVViews" => Some(Self::DvViews),
2193                _ => None,
2194            }
2195        }
2196    }
2197}
2198#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
2199pub struct Object {}
2200/// Nested message and enum types in `Object`.
2201pub mod object {
2202    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2203    pub struct ChangePayload {
2204        #[prost(enumeration = "super::SmartBlockType", tag = "1")]
2205        pub smart_block_type: i32,
2206        #[prost(string, tag = "2")]
2207        pub key: ::prost::alloc::string::String,
2208        #[prost(bytes = "vec", tag = "3")]
2209        pub data: ::prost::alloc::vec::Vec<u8>,
2210    }
2211}
2212#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2213pub struct SpaceObjectHeader {
2214    #[prost(string, tag = "1")]
2215    pub space_id: ::prost::alloc::string::String,
2216}
2217#[derive(Clone, PartialEq, ::prost::Message)]
2218pub struct ObjectType {
2219    /// leave empty in case you want to create the new one
2220    #[prost(string, tag = "1")]
2221    pub url: ::prost::alloc::string::String,
2222    /// name of objectType in singular form (can be localized for bundled types)
2223    #[prost(string, tag = "2")]
2224    pub name: ::prost::alloc::string::String,
2225    /// cannot contain more than one Relation with the same RelationType
2226    #[prost(message, repeated, tag = "3")]
2227    pub relation_links: ::prost::alloc::vec::Vec<RelationLink>,
2228    #[prost(enumeration = "object_type::Layout", tag = "4")]
2229    pub layout: i32,
2230    /// emoji symbol
2231    #[prost(string, tag = "5")]
2232    pub icon_emoji: ::prost::alloc::string::String,
2233    #[prost(string, tag = "6")]
2234    pub description: ::prost::alloc::string::String,
2235    #[prost(bool, tag = "7")]
2236    pub hidden: bool,
2237    #[prost(bool, tag = "10")]
2238    pub readonly: bool,
2239    #[prost(enumeration = "SmartBlockType", repeated, tag = "8")]
2240    pub types: ::prost::alloc::vec::Vec<i32>,
2241    /// sets locally to hide object type from set and some other places
2242    #[prost(bool, tag = "9")]
2243    pub is_archived: bool,
2244    #[prost(bool, tag = "11")]
2245    pub installed_by_default: bool,
2246    /// name of objectType (can be localized for bundled types)
2247    #[prost(string, tag = "12")]
2248    pub key: ::prost::alloc::string::String,
2249    /// revision of system objectType. Used to check if we should change type content or not
2250    #[prost(int64, tag = "13")]
2251    pub revision: i64,
2252    /// restricts creating objects of this type for users
2253    #[prost(bool, tag = "14")]
2254    pub restrict_object_creation: bool,
2255    /// color of object type icon
2256    #[prost(int64, tag = "15")]
2257    pub icon_color: i64,
2258    /// name of object type icon
2259    #[prost(string, tag = "16")]
2260    pub icon_name: ::prost::alloc::string::String,
2261    /// name of objectType in plural form (can be localized for bundled types)
2262    #[prost(string, tag = "17")]
2263    pub plural_name: ::prost::alloc::string::String,
2264}
2265/// Nested message and enum types in `ObjectType`.
2266pub mod object_type {
2267    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2268    #[repr(i32)]
2269    pub enum Layout {
2270        Basic = 0,
2271        Profile = 1,
2272        Todo = 2,
2273        Set = 3,
2274        ObjectType = 4,
2275        Relation = 5,
2276        File = 6,
2277        Dashboard = 7,
2278        Image = 8,
2279        Note = 9,
2280        Space = 10,
2281        Bookmark = 11,
2282        RelationOptionsList = 12,
2283        RelationOption = 13,
2284        Collection = 14,
2285        Audio = 15,
2286        Video = 16,
2287        Date = 17,
2288        SpaceView = 18,
2289        Participant = 19,
2290        Pdf = 20,
2291        /// deprecated
2292        ChatDeprecated = 21,
2293        ChatDerived = 22,
2294        Tag = 23,
2295        Notification = 24,
2296        MissingObject = 25,
2297        Devices = 26,
2298    }
2299    impl Layout {
2300        /// String value of the enum field names used in the ProtoBuf definition.
2301        ///
2302        /// The values are not transformed in any way and thus are considered stable
2303        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2304        pub fn as_str_name(&self) -> &'static str {
2305            match self {
2306                Self::Basic => "basic",
2307                Self::Profile => "profile",
2308                Self::Todo => "todo",
2309                Self::Set => "set",
2310                Self::ObjectType => "objectType",
2311                Self::Relation => "relation",
2312                Self::File => "file",
2313                Self::Dashboard => "dashboard",
2314                Self::Image => "image",
2315                Self::Note => "note",
2316                Self::Space => "space",
2317                Self::Bookmark => "bookmark",
2318                Self::RelationOptionsList => "relationOptionsList",
2319                Self::RelationOption => "relationOption",
2320                Self::Collection => "collection",
2321                Self::Audio => "audio",
2322                Self::Video => "video",
2323                Self::Date => "date",
2324                Self::SpaceView => "spaceView",
2325                Self::Participant => "participant",
2326                Self::Pdf => "pdf",
2327                Self::ChatDeprecated => "chatDeprecated",
2328                Self::ChatDerived => "chatDerived",
2329                Self::Tag => "tag",
2330                Self::Notification => "notification",
2331                Self::MissingObject => "missingObject",
2332                Self::Devices => "devices",
2333            }
2334        }
2335        /// Creates an enum from field names used in the ProtoBuf definition.
2336        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2337            match value {
2338                "basic" => Some(Self::Basic),
2339                "profile" => Some(Self::Profile),
2340                "todo" => Some(Self::Todo),
2341                "set" => Some(Self::Set),
2342                "objectType" => Some(Self::ObjectType),
2343                "relation" => Some(Self::Relation),
2344                "file" => Some(Self::File),
2345                "dashboard" => Some(Self::Dashboard),
2346                "image" => Some(Self::Image),
2347                "note" => Some(Self::Note),
2348                "space" => Some(Self::Space),
2349                "bookmark" => Some(Self::Bookmark),
2350                "relationOptionsList" => Some(Self::RelationOptionsList),
2351                "relationOption" => Some(Self::RelationOption),
2352                "collection" => Some(Self::Collection),
2353                "audio" => Some(Self::Audio),
2354                "video" => Some(Self::Video),
2355                "date" => Some(Self::Date),
2356                "spaceView" => Some(Self::SpaceView),
2357                "participant" => Some(Self::Participant),
2358                "pdf" => Some(Self::Pdf),
2359                "chatDeprecated" => Some(Self::ChatDeprecated),
2360                "chatDerived" => Some(Self::ChatDerived),
2361                "tag" => Some(Self::Tag),
2362                "notification" => Some(Self::Notification),
2363                "missingObject" => Some(Self::MissingObject),
2364                "devices" => Some(Self::Devices),
2365                _ => None,
2366            }
2367        }
2368    }
2369}
2370#[derive(Clone, PartialEq, ::prost::Message)]
2371pub struct Layout {
2372    #[prost(enumeration = "object_type::Layout", tag = "1")]
2373    pub id: i32,
2374    #[prost(string, tag = "2")]
2375    pub name: ::prost::alloc::string::String,
2376    /// relations required for this object type
2377    #[prost(message, repeated, tag = "3")]
2378    pub required_relations: ::prost::alloc::vec::Vec<Relation>,
2379}
2380#[derive(Clone, PartialEq, ::prost::Message)]
2381pub struct RelationWithValue {
2382    #[prost(message, optional, tag = "1")]
2383    pub relation: ::core::option::Option<Relation>,
2384    #[prost(message, optional, tag = "2")]
2385    pub value: ::core::option::Option<::prost_types::Value>,
2386}
2387/// Relation describe the human-interpreted relation type. It may be something like "Date of creation, format=date" or "Assignee, format=objectId, objectType=person"
2388#[derive(Clone, PartialEq, ::prost::Message)]
2389pub struct Relation {
2390    #[prost(string, tag = "100")]
2391    pub id: ::prost::alloc::string::String,
2392    /// Key under which the value is stored in the map. Must be unique for the object type.
2393    /// It usually auto-generated bsonid, but also may be something human-readable in case of prebuilt types.
2394    #[prost(string, tag = "1")]
2395    pub key: ::prost::alloc::string::String,
2396    /// format of the underlying data
2397    #[prost(enumeration = "RelationFormat", tag = "2")]
2398    pub format: i32,
2399    /// name to show (can be localized for bundled types)
2400    #[prost(string, tag = "3")]
2401    pub name: ::prost::alloc::string::String,
2402    #[prost(message, optional, tag = "4")]
2403    pub default_value: ::core::option::Option<::prost_types::Value>,
2404    /// where the data is stored
2405    #[prost(enumeration = "relation::DataSource", tag = "5")]
2406    pub data_source: i32,
2407    /// internal, not displayed to user (e.g. coverX, coverY)
2408    #[prost(bool, tag = "6")]
2409    pub hidden: bool,
2410    /// value not editable by user tobe renamed to readonlyValue
2411    #[prost(bool, tag = "7")]
2412    pub read_only: bool,
2413    /// relation metadata, eg name and format is not editable by user
2414    #[prost(bool, tag = "15")]
2415    pub read_only_relation: bool,
2416    /// allow multiple values (stored in pb list)
2417    #[prost(bool, tag = "8")]
2418    pub multi: bool,
2419    /// URL of object type, empty to allow link to any object
2420    #[prost(string, repeated, tag = "9")]
2421    pub object_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2422    /// index 10, 11 was used in internal-only builds. Can be reused, but may break some test accounts
2423    ///
2424    /// default dictionary with unique values to choose for select/multiSelect format
2425    #[prost(message, repeated, tag = "12")]
2426    pub select_dict: ::prost::alloc::vec::Vec<relation::Option>,
2427    /// max number of values can be set for this relation. 0 means no limit. 1 means the value can be stored in non-repeated field
2428    #[prost(int32, tag = "13")]
2429    pub max_count: i32,
2430    #[prost(string, tag = "14")]
2431    pub description: ::prost::alloc::string::String,
2432    /// on-store fields, injected only locally
2433    ///
2434    /// deprecated, to be removed
2435    #[prost(enumeration = "relation::Scope", tag = "20")]
2436    pub scope: i32,
2437    /// creator profile id
2438    #[prost(string, tag = "21")]
2439    pub creator: ::prost::alloc::string::String,
2440    /// revision of system relation. Used to check if we should change relation content or not
2441    #[prost(int64, tag = "22")]
2442    pub revision: i64,
2443    /// indicates whether value of relation with date format should be processed with seconds precision
2444    #[prost(bool, tag = "23")]
2445    pub include_time: bool,
2446}
2447/// Nested message and enum types in `Relation`.
2448pub mod relation {
2449    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2450    pub struct Option {
2451        /// id generated automatically if omitted
2452        #[prost(string, tag = "1")]
2453        pub id: ::prost::alloc::string::String,
2454        #[prost(string, tag = "2")]
2455        pub text: ::prost::alloc::string::String,
2456        /// stored
2457        #[prost(string, tag = "3")]
2458        pub color: ::prost::alloc::string::String,
2459        /// 4 is reserved for old relation format
2460        ///
2461        /// stored
2462        #[prost(string, tag = "5")]
2463        pub relation_key: ::prost::alloc::string::String,
2464        /// lexicographic id of relation option for ordering
2465        #[prost(string, tag = "6")]
2466        pub order_id: ::prost::alloc::string::String,
2467    }
2468    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2469    #[repr(i32)]
2470    pub enum Scope {
2471        /// stored within the object
2472        Object = 0,
2473        /// stored within the object type
2474        Type = 1,
2475        /// aggregated from the dataview of sets of the same object type
2476        SetOfTheSameType = 2,
2477        /// aggregated from the dataview of sets of the same object type
2478        ObjectsOfTheSameType = 3,
2479        /// aggregated from relations library
2480        Library = 4,
2481    }
2482    impl Scope {
2483        /// String value of the enum field names used in the ProtoBuf definition.
2484        ///
2485        /// The values are not transformed in any way and thus are considered stable
2486        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2487        pub fn as_str_name(&self) -> &'static str {
2488            match self {
2489                Self::Object => "object",
2490                Self::Type => "type",
2491                Self::SetOfTheSameType => "setOfTheSameType",
2492                Self::ObjectsOfTheSameType => "objectsOfTheSameType",
2493                Self::Library => "library",
2494            }
2495        }
2496        /// Creates an enum from field names used in the ProtoBuf definition.
2497        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2498            match value {
2499                "object" => Some(Self::Object),
2500                "type" => Some(Self::Type),
2501                "setOfTheSameType" => Some(Self::SetOfTheSameType),
2502                "objectsOfTheSameType" => Some(Self::ObjectsOfTheSameType),
2503                "library" => Some(Self::Library),
2504                _ => None,
2505            }
2506        }
2507    }
2508    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2509    #[repr(i32)]
2510    pub enum DataSource {
2511        /// default, stored inside the object's details
2512        Details = 0,
2513        /// stored locally, e.g. in badger or generated on the fly
2514        Derived = 1,
2515        /// stored in the account DB. means existing only for specific anytype account
2516        Account = 2,
2517        /// stored locally
2518        Local = 3,
2519    }
2520    impl DataSource {
2521        /// String value of the enum field names used in the ProtoBuf definition.
2522        ///
2523        /// The values are not transformed in any way and thus are considered stable
2524        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2525        pub fn as_str_name(&self) -> &'static str {
2526            match self {
2527                Self::Details => "details",
2528                Self::Derived => "derived",
2529                Self::Account => "account",
2530                Self::Local => "local",
2531            }
2532        }
2533        /// Creates an enum from field names used in the ProtoBuf definition.
2534        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2535            match value {
2536                "details" => Some(Self::Details),
2537                "derived" => Some(Self::Derived),
2538                "account" => Some(Self::Account),
2539                "local" => Some(Self::Local),
2540                _ => None,
2541            }
2542        }
2543    }
2544}
2545#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2546pub struct RelationLink {
2547    #[prost(string, tag = "1")]
2548    pub key: ::prost::alloc::string::String,
2549    #[prost(enumeration = "RelationFormat", tag = "2")]
2550    pub format: i32,
2551}
2552#[derive(Clone, PartialEq, ::prost::Message)]
2553pub struct Relations {
2554    #[prost(message, repeated, tag = "1")]
2555    pub relations: ::prost::alloc::vec::Vec<Relation>,
2556}
2557#[derive(Clone, PartialEq, ::prost::Message)]
2558pub struct RelationOptions {
2559    #[prost(message, repeated, tag = "1")]
2560    pub options: ::prost::alloc::vec::Vec<relation::Option>,
2561}
2562#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
2563pub struct InternalFlag {
2564    #[prost(enumeration = "internal_flag::Value", tag = "1")]
2565    pub value: i32,
2566}
2567/// Nested message and enum types in `InternalFlag`.
2568pub mod internal_flag {
2569    /// Use such a weird construction due to the issue with imported repeated enum type
2570    /// Look <https://github.com/golang/protobuf/issues/1135> for more information.
2571    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2572    #[repr(i32)]
2573    pub enum Value {
2574        EditorDeleteEmpty = 0,
2575        EditorSelectType = 1,
2576        EditorSelectTemplate = 2,
2577        CollectionDontIndexLinks = 3,
2578    }
2579    impl Value {
2580        /// String value of the enum field names used in the ProtoBuf definition.
2581        ///
2582        /// The values are not transformed in any way and thus are considered stable
2583        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2584        pub fn as_str_name(&self) -> &'static str {
2585            match self {
2586                Self::EditorDeleteEmpty => "editorDeleteEmpty",
2587                Self::EditorSelectType => "editorSelectType",
2588                Self::EditorSelectTemplate => "editorSelectTemplate",
2589                Self::CollectionDontIndexLinks => "collectionDontIndexLinks",
2590            }
2591        }
2592        /// Creates an enum from field names used in the ProtoBuf definition.
2593        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2594            match value {
2595                "editorDeleteEmpty" => Some(Self::EditorDeleteEmpty),
2596                "editorSelectType" => Some(Self::EditorSelectType),
2597                "editorSelectTemplate" => Some(Self::EditorSelectTemplate),
2598                "collectionDontIndexLinks" => Some(Self::CollectionDontIndexLinks),
2599                _ => None,
2600            }
2601        }
2602    }
2603}
2604/// Works with a smart blocks: Page, Dashboard
2605/// Dashboard opened, click on a page, Rpc.Block.open, Block.ShowFullscreen(PageBlock)
2606#[derive(Clone, PartialEq, ::prost::Message)]
2607pub struct ObjectView {
2608    /// Root block id
2609    #[prost(string, tag = "1")]
2610    pub root_id: ::prost::alloc::string::String,
2611    /// dependent simple blocks (descendants)
2612    #[prost(message, repeated, tag = "2")]
2613    pub blocks: ::prost::alloc::vec::Vec<Block>,
2614    /// details for the current and dependent objects
2615    #[prost(message, repeated, tag = "3")]
2616    pub details: ::prost::alloc::vec::Vec<object_view::DetailsSet>,
2617    #[prost(enumeration = "SmartBlockType", tag = "4")]
2618    pub r#type: i32,
2619    /// DEPRECATED, use relationLinks instead
2620    #[prost(message, repeated, tag = "7")]
2621    pub relations: ::prost::alloc::vec::Vec<Relation>,
2622    #[prost(message, repeated, tag = "10")]
2623    pub relation_links: ::prost::alloc::vec::Vec<RelationLink>,
2624    /// object restrictions
2625    #[prost(message, optional, tag = "8")]
2626    pub restrictions: ::core::option::Option<Restrictions>,
2627    #[prost(message, optional, tag = "9")]
2628    pub history: ::core::option::Option<object_view::HistorySize>,
2629    #[prost(message, repeated, tag = "11")]
2630    pub block_participants: ::prost::alloc::vec::Vec<object_view::BlockParticipant>,
2631}
2632/// Nested message and enum types in `ObjectView`.
2633pub mod object_view {
2634    #[derive(Clone, PartialEq, ::prost::Message)]
2635    pub struct DetailsSet {
2636        /// context objectId
2637        #[prost(string, tag = "1")]
2638        pub id: ::prost::alloc::string::String,
2639        /// can not be a partial state. Should replace client details state
2640        #[prost(message, optional, tag = "2")]
2641        pub details: ::core::option::Option<::prost_types::Struct>,
2642        #[prost(string, repeated, tag = "3")]
2643        pub sub_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
2644    }
2645    #[derive(Clone, PartialEq, ::prost::Message)]
2646    pub struct RelationWithValuePerObject {
2647        #[prost(string, tag = "1")]
2648        pub object_id: ::prost::alloc::string::String,
2649        #[prost(message, repeated, tag = "2")]
2650        pub relations: ::prost::alloc::vec::Vec<super::RelationWithValue>,
2651    }
2652    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
2653    pub struct HistorySize {
2654        #[prost(int32, tag = "1")]
2655        pub undo: i32,
2656        #[prost(int32, tag = "2")]
2657        pub redo: i32,
2658    }
2659    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2660    pub struct BlockParticipant {
2661        #[prost(string, tag = "1")]
2662        pub block_id: ::prost::alloc::string::String,
2663        #[prost(string, tag = "2")]
2664        pub participant_id: ::prost::alloc::string::String,
2665    }
2666}
2667#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2668pub struct ParticipantPermissionChange {
2669    #[prost(string, tag = "1")]
2670    pub identity: ::prost::alloc::string::String,
2671    #[prost(enumeration = "ParticipantPermissions", tag = "2")]
2672    pub perms: i32,
2673}
2674#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2675pub struct Metadata {
2676    #[prost(oneof = "metadata::PayloadValue", tags = "1")]
2677    pub payload_value: ::core::option::Option<metadata::PayloadValue>,
2678}
2679/// Nested message and enum types in `Metadata`.
2680pub mod metadata {
2681    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
2682    pub struct Payload {}
2683    /// Nested message and enum types in `Payload`.
2684    pub mod payload {
2685        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2686        pub struct IdentityPayload {
2687            #[prost(bytes = "vec", tag = "1")]
2688            pub profile_sym_key: ::prost::alloc::vec::Vec<u8>,
2689        }
2690    }
2691    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
2692    pub enum PayloadValue {
2693        #[prost(message, tag = "1")]
2694        Identity(payload::IdentityPayload),
2695    }
2696}
2697#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2698pub struct Notification {
2699    #[prost(string, tag = "1")]
2700    pub id: ::prost::alloc::string::String,
2701    #[prost(int64, tag = "2")]
2702    pub create_time: i64,
2703    #[prost(enumeration = "notification::Status", tag = "4")]
2704    pub status: i32,
2705    #[prost(bool, tag = "5")]
2706    pub is_local: bool,
2707    #[prost(string, tag = "7")]
2708    pub space: ::prost::alloc::string::String,
2709    #[prost(string, tag = "14")]
2710    pub acl_head_id: ::prost::alloc::string::String,
2711    #[prost(
2712        oneof = "notification::Payload",
2713        tags = "6, 8, 9, 10, 11, 13, 15, 16, 17, 18"
2714    )]
2715    pub payload: ::core::option::Option<notification::Payload>,
2716}
2717/// Nested message and enum types in `Notification`.
2718pub mod notification {
2719    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2720    pub struct Import {
2721        #[prost(string, tag = "1")]
2722        pub process_id: ::prost::alloc::string::String,
2723        #[prost(enumeration = "super::import::ErrorCode", tag = "2")]
2724        pub error_code: i32,
2725        #[prost(enumeration = "super::import::Type", tag = "3")]
2726        pub import_type: i32,
2727        #[prost(string, tag = "4")]
2728        pub space_id: ::prost::alloc::string::String,
2729        #[prost(string, tag = "5")]
2730        pub name: ::prost::alloc::string::String,
2731        #[prost(string, tag = "6")]
2732        pub space_name: ::prost::alloc::string::String,
2733    }
2734    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
2735    pub struct Export {
2736        #[prost(enumeration = "export::Code", tag = "2")]
2737        pub error_code: i32,
2738        #[prost(enumeration = "super::export::Format", tag = "3")]
2739        pub export_type: i32,
2740    }
2741    /// Nested message and enum types in `Export`.
2742    pub mod export {
2743        #[derive(
2744            Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
2745        )]
2746        #[repr(i32)]
2747        pub enum Code {
2748            Null = 0,
2749            UnknownError = 1,
2750            BadInput = 2,
2751        }
2752        impl Code {
2753            /// String value of the enum field names used in the ProtoBuf definition.
2754            ///
2755            /// The values are not transformed in any way and thus are considered stable
2756            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2757            pub fn as_str_name(&self) -> &'static str {
2758                match self {
2759                    Self::Null => "NULL",
2760                    Self::UnknownError => "UNKNOWN_ERROR",
2761                    Self::BadInput => "BAD_INPUT",
2762                }
2763            }
2764            /// Creates an enum from field names used in the ProtoBuf definition.
2765            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2766                match value {
2767                    "NULL" => Some(Self::Null),
2768                    "UNKNOWN_ERROR" => Some(Self::UnknownError),
2769                    "BAD_INPUT" => Some(Self::BadInput),
2770                    _ => None,
2771                }
2772            }
2773        }
2774    }
2775    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2776    pub struct GalleryImport {
2777        #[prost(string, tag = "1")]
2778        pub process_id: ::prost::alloc::string::String,
2779        #[prost(enumeration = "super::import::ErrorCode", tag = "2")]
2780        pub error_code: i32,
2781        #[prost(string, tag = "3")]
2782        pub space_id: ::prost::alloc::string::String,
2783        #[prost(string, tag = "4")]
2784        pub name: ::prost::alloc::string::String,
2785        #[prost(string, tag = "5")]
2786        pub space_name: ::prost::alloc::string::String,
2787    }
2788    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2789    pub struct RequestToJoin {
2790        #[prost(string, tag = "1")]
2791        pub space_id: ::prost::alloc::string::String,
2792        #[prost(string, tag = "2")]
2793        pub identity: ::prost::alloc::string::String,
2794        #[prost(string, tag = "3")]
2795        pub identity_name: ::prost::alloc::string::String,
2796        #[prost(string, tag = "4")]
2797        pub identity_icon: ::prost::alloc::string::String,
2798        #[prost(string, tag = "5")]
2799        pub space_name: ::prost::alloc::string::String,
2800    }
2801    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
2802    pub struct Test {}
2803    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2804    pub struct ParticipantRequestApproved {
2805        #[prost(string, tag = "1")]
2806        pub space_id: ::prost::alloc::string::String,
2807        #[prost(enumeration = "super::ParticipantPermissions", tag = "2")]
2808        pub permissions: i32,
2809        #[prost(string, tag = "5")]
2810        pub space_name: ::prost::alloc::string::String,
2811    }
2812    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2813    pub struct RequestToLeave {
2814        #[prost(string, tag = "1")]
2815        pub space_id: ::prost::alloc::string::String,
2816        #[prost(string, tag = "2")]
2817        pub identity: ::prost::alloc::string::String,
2818        #[prost(string, tag = "3")]
2819        pub identity_name: ::prost::alloc::string::String,
2820        #[prost(string, tag = "4")]
2821        pub identity_icon: ::prost::alloc::string::String,
2822        #[prost(string, tag = "5")]
2823        pub space_name: ::prost::alloc::string::String,
2824    }
2825    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2826    pub struct ParticipantRemove {
2827        #[prost(string, tag = "1")]
2828        pub identity: ::prost::alloc::string::String,
2829        #[prost(string, tag = "2")]
2830        pub identity_name: ::prost::alloc::string::String,
2831        #[prost(string, tag = "3")]
2832        pub identity_icon: ::prost::alloc::string::String,
2833        #[prost(string, tag = "4")]
2834        pub space_id: ::prost::alloc::string::String,
2835        #[prost(string, tag = "5")]
2836        pub space_name: ::prost::alloc::string::String,
2837    }
2838    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2839    pub struct ParticipantRequestDecline {
2840        #[prost(string, tag = "1")]
2841        pub space_id: ::prost::alloc::string::String,
2842        #[prost(string, tag = "3")]
2843        pub space_name: ::prost::alloc::string::String,
2844    }
2845    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
2846    pub struct ParticipantPermissionsChange {
2847        #[prost(string, tag = "1")]
2848        pub space_id: ::prost::alloc::string::String,
2849        #[prost(enumeration = "super::ParticipantPermissions", tag = "2")]
2850        pub permissions: i32,
2851        #[prost(string, tag = "3")]
2852        pub space_name: ::prost::alloc::string::String,
2853    }
2854    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2855    #[repr(i32)]
2856    pub enum Status {
2857        Created = 0,
2858        Shown = 1,
2859        Read = 2,
2860        Replied = 3,
2861    }
2862    impl Status {
2863        /// String value of the enum field names used in the ProtoBuf definition.
2864        ///
2865        /// The values are not transformed in any way and thus are considered stable
2866        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2867        pub fn as_str_name(&self) -> &'static str {
2868            match self {
2869                Self::Created => "Created",
2870                Self::Shown => "Shown",
2871                Self::Read => "Read",
2872                Self::Replied => "Replied",
2873            }
2874        }
2875        /// Creates an enum from field names used in the ProtoBuf definition.
2876        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2877            match value {
2878                "Created" => Some(Self::Created),
2879                "Shown" => Some(Self::Shown),
2880                "Read" => Some(Self::Read),
2881                "Replied" => Some(Self::Replied),
2882                _ => None,
2883            }
2884        }
2885    }
2886    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2887    #[repr(i32)]
2888    pub enum ActionType {
2889        Close = 0,
2890    }
2891    impl ActionType {
2892        /// String value of the enum field names used in the ProtoBuf definition.
2893        ///
2894        /// The values are not transformed in any way and thus are considered stable
2895        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2896        pub fn as_str_name(&self) -> &'static str {
2897            match self {
2898                Self::Close => "CLOSE",
2899            }
2900        }
2901        /// Creates an enum from field names used in the ProtoBuf definition.
2902        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2903            match value {
2904                "CLOSE" => Some(Self::Close),
2905                _ => None,
2906            }
2907        }
2908    }
2909    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
2910    pub enum Payload {
2911        #[prost(message, tag = "6")]
2912        Import(Import),
2913        #[prost(message, tag = "8")]
2914        Export(Export),
2915        #[prost(message, tag = "9")]
2916        GalleryImport(GalleryImport),
2917        #[prost(message, tag = "10")]
2918        RequestToJoin(RequestToJoin),
2919        #[prost(message, tag = "11")]
2920        Test(Test),
2921        #[prost(message, tag = "13")]
2922        ParticipantRequestApproved(ParticipantRequestApproved),
2923        #[prost(message, tag = "15")]
2924        RequestToLeave(RequestToLeave),
2925        #[prost(message, tag = "16")]
2926        ParticipantRemove(ParticipantRemove),
2927        #[prost(message, tag = "17")]
2928        ParticipantRequestDecline(ParticipantRequestDecline),
2929        #[prost(message, tag = "18")]
2930        ParticipantPermissionsChange(ParticipantPermissionsChange),
2931    }
2932}
2933#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
2934pub struct Export {}
2935/// Nested message and enum types in `Export`.
2936pub mod export {
2937    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2938    #[repr(i32)]
2939    pub enum Format {
2940        Markdown = 0,
2941        Protobuf = 1,
2942        Json = 2,
2943        Dot = 3,
2944        Svg = 4,
2945        GraphJson = 5,
2946    }
2947    impl Format {
2948        /// String value of the enum field names used in the ProtoBuf definition.
2949        ///
2950        /// The values are not transformed in any way and thus are considered stable
2951        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2952        pub fn as_str_name(&self) -> &'static str {
2953            match self {
2954                Self::Markdown => "Markdown",
2955                Self::Protobuf => "Protobuf",
2956                Self::Json => "JSON",
2957                Self::Dot => "DOT",
2958                Self::Svg => "SVG",
2959                Self::GraphJson => "GRAPH_JSON",
2960            }
2961        }
2962        /// Creates an enum from field names used in the ProtoBuf definition.
2963        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
2964            match value {
2965                "Markdown" => Some(Self::Markdown),
2966                "Protobuf" => Some(Self::Protobuf),
2967                "JSON" => Some(Self::Json),
2968                "DOT" => Some(Self::Dot),
2969                "SVG" => Some(Self::Svg),
2970                "GRAPH_JSON" => Some(Self::GraphJson),
2971                _ => None,
2972            }
2973        }
2974    }
2975}
2976#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
2977pub struct Import {}
2978/// Nested message and enum types in `Import`.
2979pub mod import {
2980    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
2981    #[repr(i32)]
2982    pub enum Type {
2983        Notion = 0,
2984        Markdown = 1,
2985        /// external developers use it
2986        External = 2,
2987        Pb = 3,
2988        Html = 4,
2989        Txt = 5,
2990        Csv = 6,
2991        /// Markdown with obsidian improvements
2992        Obsidian = 7,
2993    }
2994    impl Type {
2995        /// String value of the enum field names used in the ProtoBuf definition.
2996        ///
2997        /// The values are not transformed in any way and thus are considered stable
2998        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
2999        pub fn as_str_name(&self) -> &'static str {
3000            match self {
3001                Self::Notion => "Notion",
3002                Self::Markdown => "Markdown",
3003                Self::External => "External",
3004                Self::Pb => "Pb",
3005                Self::Html => "Html",
3006                Self::Txt => "Txt",
3007                Self::Csv => "Csv",
3008                Self::Obsidian => "Obsidian",
3009            }
3010        }
3011        /// Creates an enum from field names used in the ProtoBuf definition.
3012        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3013            match value {
3014                "Notion" => Some(Self::Notion),
3015                "Markdown" => Some(Self::Markdown),
3016                "External" => Some(Self::External),
3017                "Pb" => Some(Self::Pb),
3018                "Html" => Some(Self::Html),
3019                "Txt" => Some(Self::Txt),
3020                "Csv" => Some(Self::Csv),
3021                "Obsidian" => Some(Self::Obsidian),
3022                _ => None,
3023            }
3024        }
3025    }
3026    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3027    #[repr(i32)]
3028    pub enum ErrorCode {
3029        Null = 0,
3030        UnknownError = 1,
3031        BadInput = 2,
3032        InternalError = 3,
3033        FileLoadError = 8,
3034        ImportIsCanceled = 6,
3035        NotionNoObjectsInIntegration = 5,
3036        NotionServerIsUnavailable = 12,
3037        NotionRateLimitExceeded = 13,
3038        FileImportNoObjectsInZipArchive = 14,
3039        FileImportNoObjectsInDirectory = 17,
3040        HtmlWrongHtmlStructure = 10,
3041        PbNotAnyblockFormat = 11,
3042        CsvLimitOfRowsOrRelationsExceeded = 7,
3043        InsufficientPermissions = 9,
3044    }
3045    impl ErrorCode {
3046        /// String value of the enum field names used in the ProtoBuf definition.
3047        ///
3048        /// The values are not transformed in any way and thus are considered stable
3049        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3050        pub fn as_str_name(&self) -> &'static str {
3051            match self {
3052                Self::Null => "NULL",
3053                Self::UnknownError => "UNKNOWN_ERROR",
3054                Self::BadInput => "BAD_INPUT",
3055                Self::InternalError => "INTERNAL_ERROR",
3056                Self::FileLoadError => "FILE_LOAD_ERROR",
3057                Self::ImportIsCanceled => "IMPORT_IS_CANCELED",
3058                Self::NotionNoObjectsInIntegration => "NOTION_NO_OBJECTS_IN_INTEGRATION",
3059                Self::NotionServerIsUnavailable => "NOTION_SERVER_IS_UNAVAILABLE",
3060                Self::NotionRateLimitExceeded => "NOTION_RATE_LIMIT_EXCEEDED",
3061                Self::FileImportNoObjectsInZipArchive => "FILE_IMPORT_NO_OBJECTS_IN_ZIP_ARCHIVE",
3062                Self::FileImportNoObjectsInDirectory => "FILE_IMPORT_NO_OBJECTS_IN_DIRECTORY",
3063                Self::HtmlWrongHtmlStructure => "HTML_WRONG_HTML_STRUCTURE",
3064                Self::PbNotAnyblockFormat => "PB_NOT_ANYBLOCK_FORMAT",
3065                Self::CsvLimitOfRowsOrRelationsExceeded => {
3066                    "CSV_LIMIT_OF_ROWS_OR_RELATIONS_EXCEEDED"
3067                }
3068                Self::InsufficientPermissions => "INSUFFICIENT_PERMISSIONS",
3069            }
3070        }
3071        /// Creates an enum from field names used in the ProtoBuf definition.
3072        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3073            match value {
3074                "NULL" => Some(Self::Null),
3075                "UNKNOWN_ERROR" => Some(Self::UnknownError),
3076                "BAD_INPUT" => Some(Self::BadInput),
3077                "INTERNAL_ERROR" => Some(Self::InternalError),
3078                "FILE_LOAD_ERROR" => Some(Self::FileLoadError),
3079                "IMPORT_IS_CANCELED" => Some(Self::ImportIsCanceled),
3080                "NOTION_NO_OBJECTS_IN_INTEGRATION" => Some(Self::NotionNoObjectsInIntegration),
3081                "NOTION_SERVER_IS_UNAVAILABLE" => Some(Self::NotionServerIsUnavailable),
3082                "NOTION_RATE_LIMIT_EXCEEDED" => Some(Self::NotionRateLimitExceeded),
3083                "FILE_IMPORT_NO_OBJECTS_IN_ZIP_ARCHIVE" => {
3084                    Some(Self::FileImportNoObjectsInZipArchive)
3085                }
3086                "FILE_IMPORT_NO_OBJECTS_IN_DIRECTORY" => Some(Self::FileImportNoObjectsInDirectory),
3087                "HTML_WRONG_HTML_STRUCTURE" => Some(Self::HtmlWrongHtmlStructure),
3088                "PB_NOT_ANYBLOCK_FORMAT" => Some(Self::PbNotAnyblockFormat),
3089                "CSV_LIMIT_OF_ROWS_OR_RELATIONS_EXCEEDED" => {
3090                    Some(Self::CsvLimitOfRowsOrRelationsExceeded)
3091                }
3092                "INSUFFICIENT_PERMISSIONS" => Some(Self::InsufficientPermissions),
3093                _ => None,
3094            }
3095        }
3096    }
3097}
3098#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
3099pub struct Invite {
3100    #[prost(bytes = "vec", tag = "1")]
3101    pub payload: ::prost::alloc::vec::Vec<u8>,
3102    #[prost(bytes = "vec", tag = "2")]
3103    pub signature: ::prost::alloc::vec::Vec<u8>,
3104}
3105#[derive(Clone, PartialEq, ::prost::Message)]
3106pub struct InvitePayload {
3107    #[prost(string, tag = "1")]
3108    pub creator_identity: ::prost::alloc::string::String,
3109    #[prost(string, tag = "2")]
3110    pub creator_name: ::prost::alloc::string::String,
3111    #[prost(string, tag = "12")]
3112    pub creator_icon_cid: ::prost::alloc::string::String,
3113    #[prost(message, repeated, tag = "13")]
3114    pub creator_icon_encryption_keys: ::prost::alloc::vec::Vec<FileEncryptionKey>,
3115    #[prost(bytes = "vec", tag = "3")]
3116    pub acl_key: ::prost::alloc::vec::Vec<u8>,
3117    #[prost(string, tag = "4")]
3118    pub space_id: ::prost::alloc::string::String,
3119    #[prost(string, tag = "5")]
3120    pub space_name: ::prost::alloc::string::String,
3121    #[prost(string, tag = "6")]
3122    pub space_icon_cid: ::prost::alloc::string::String,
3123    #[prost(uint32, tag = "10")]
3124    pub space_icon_option: u32,
3125    #[prost(uint32, tag = "11")]
3126    pub space_ux_type: u32,
3127    #[prost(message, repeated, tag = "7")]
3128    pub space_icon_encryption_keys: ::prost::alloc::vec::Vec<FileEncryptionKey>,
3129    #[prost(enumeration = "InviteType", tag = "8")]
3130    pub invite_type: i32,
3131    #[prost(bytes = "vec", tag = "9")]
3132    pub guest_key: ::prost::alloc::vec::Vec<u8>,
3133}
3134#[derive(Clone, PartialEq, ::prost::Message)]
3135pub struct IdentityProfile {
3136    #[prost(string, tag = "1")]
3137    pub identity: ::prost::alloc::string::String,
3138    #[prost(string, tag = "2")]
3139    pub name: ::prost::alloc::string::String,
3140    #[prost(string, tag = "3")]
3141    pub icon_cid: ::prost::alloc::string::String,
3142    #[prost(message, repeated, tag = "4")]
3143    pub icon_encryption_keys: ::prost::alloc::vec::Vec<FileEncryptionKey>,
3144    #[prost(string, tag = "5")]
3145    pub description: ::prost::alloc::string::String,
3146    #[prost(string, tag = "6")]
3147    pub global_name: ::prost::alloc::string::String,
3148}
3149#[derive(Clone, PartialEq, ::prost::Message)]
3150pub struct IdentityProfileWithKey {
3151    #[prost(message, optional, tag = "1")]
3152    pub identity_profile: ::core::option::Option<IdentityProfile>,
3153    #[prost(bytes = "vec", tag = "2")]
3154    pub request_metadata: ::prost::alloc::vec::Vec<u8>,
3155}
3156#[derive(Clone, PartialEq, ::prost::Message)]
3157pub struct FileInfo {
3158    #[prost(string, tag = "1")]
3159    pub file_id: ::prost::alloc::string::String,
3160    #[prost(message, repeated, tag = "2")]
3161    pub encryption_keys: ::prost::alloc::vec::Vec<FileEncryptionKey>,
3162}
3163#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
3164pub struct FileEncryptionKey {
3165    #[prost(string, tag = "1")]
3166    pub path: ::prost::alloc::string::String,
3167    #[prost(string, tag = "2")]
3168    pub key: ::prost::alloc::string::String,
3169}
3170#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
3171pub struct ManifestInfo {
3172    #[prost(string, tag = "1")]
3173    pub schema: ::prost::alloc::string::String,
3174    #[prost(string, tag = "2")]
3175    pub id: ::prost::alloc::string::String,
3176    #[prost(string, tag = "3")]
3177    pub name: ::prost::alloc::string::String,
3178    #[prost(string, tag = "4")]
3179    pub author: ::prost::alloc::string::String,
3180    #[prost(string, tag = "5")]
3181    pub license: ::prost::alloc::string::String,
3182    #[prost(string, tag = "6")]
3183    pub title: ::prost::alloc::string::String,
3184    #[prost(string, tag = "7")]
3185    pub description: ::prost::alloc::string::String,
3186    #[prost(string, repeated, tag = "8")]
3187    pub screenshots: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3188    #[prost(string, tag = "9")]
3189    pub download_link: ::prost::alloc::string::String,
3190    #[prost(int32, tag = "10")]
3191    pub file_size: i32,
3192    #[prost(string, repeated, tag = "11")]
3193    pub categories: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3194    #[prost(string, tag = "12")]
3195    pub language: ::prost::alloc::string::String,
3196}
3197#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
3198pub struct Membership {
3199    /// it was Tier before, changed to int32 to allow dynamic values
3200    #[prost(uint32, tag = "1")]
3201    pub tier: u32,
3202    #[prost(enumeration = "membership::Status", tag = "2")]
3203    pub status: i32,
3204    #[prost(uint64, tag = "3")]
3205    pub date_started: u64,
3206    #[prost(uint64, tag = "4")]
3207    pub date_ends: u64,
3208    #[prost(bool, tag = "5")]
3209    pub is_auto_renew: bool,
3210    #[prost(enumeration = "membership::PaymentMethod", tag = "6")]
3211    pub payment_method: i32,
3212    /// can be empty if user did not ask for any name
3213    #[prost(string, tag = "7")]
3214    pub ns_name: ::prost::alloc::string::String,
3215    #[prost(enumeration = "NameserviceNameType", tag = "8")]
3216    pub ns_name_type: i32,
3217    /// if the email was verified by the user or set during the checkout - it will be here
3218    #[prost(string, tag = "9")]
3219    pub user_email: ::prost::alloc::string::String,
3220    #[prost(bool, tag = "10")]
3221    pub subscribe_to_newsletter: bool,
3222}
3223/// Nested message and enum types in `Membership`.
3224pub mod membership {
3225    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3226    #[repr(i32)]
3227    pub enum Status {
3228        Unknown = 0,
3229        /// please wait a bit more, we are still processing your request
3230        /// the payment is confirmed, but we need more time to do some side-effects:
3231        ///
3232        /// * increase limits
3233        /// * send emails
3234        /// * allocate names
3235        Pending = 1,
3236        /// the membership is active, ready to use!
3237        Active = 2,
3238        /// in some cases we need to finalize the process:
3239        ///
3240        /// * if user has bought membership directly without first calling
3241        ///   the BuySubscription method
3242        ///   in this case please call Finalize to finish the process
3243        PendingRequiresFinalization = 3,
3244    }
3245    impl Status {
3246        /// String value of the enum field names used in the ProtoBuf definition.
3247        ///
3248        /// The values are not transformed in any way and thus are considered stable
3249        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3250        pub fn as_str_name(&self) -> &'static str {
3251            match self {
3252                Self::Unknown => "StatusUnknown",
3253                Self::Pending => "StatusPending",
3254                Self::Active => "StatusActive",
3255                Self::PendingRequiresFinalization => "StatusPendingRequiresFinalization",
3256            }
3257        }
3258        /// Creates an enum from field names used in the ProtoBuf definition.
3259        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3260            match value {
3261                "StatusUnknown" => Some(Self::Unknown),
3262                "StatusPending" => Some(Self::Pending),
3263                "StatusActive" => Some(Self::Active),
3264                "StatusPendingRequiresFinalization" => Some(Self::PendingRequiresFinalization),
3265                _ => None,
3266            }
3267        }
3268    }
3269    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3270    #[repr(i32)]
3271    pub enum PaymentMethod {
3272        MethodNone = 0,
3273        MethodStripe = 1,
3274        MethodCrypto = 2,
3275        MethodInappApple = 3,
3276        MethodInappGoogle = 4,
3277    }
3278    impl PaymentMethod {
3279        /// String value of the enum field names used in the ProtoBuf definition.
3280        ///
3281        /// The values are not transformed in any way and thus are considered stable
3282        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3283        pub fn as_str_name(&self) -> &'static str {
3284            match self {
3285                Self::MethodNone => "MethodNone",
3286                Self::MethodStripe => "MethodStripe",
3287                Self::MethodCrypto => "MethodCrypto",
3288                Self::MethodInappApple => "MethodInappApple",
3289                Self::MethodInappGoogle => "MethodInappGoogle",
3290            }
3291        }
3292        /// Creates an enum from field names used in the ProtoBuf definition.
3293        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3294            match value {
3295                "MethodNone" => Some(Self::MethodNone),
3296                "MethodStripe" => Some(Self::MethodStripe),
3297                "MethodCrypto" => Some(Self::MethodCrypto),
3298                "MethodInappApple" => Some(Self::MethodInappApple),
3299                "MethodInappGoogle" => Some(Self::MethodInappGoogle),
3300                _ => None,
3301            }
3302        }
3303    }
3304    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3305    #[repr(i32)]
3306    pub enum EmailVerificationStatus {
3307        /// user NEVER comleted the verification of the email
3308        StatusNotVerified = 0,
3309        /// user has asked for new code, but did not enter it yet
3310        /// (even if email was verified before, you can ask to UPDATE your e-mail)
3311        /// please wait, you can not ask for more codes yet
3312        StatusCodeSent = 1,
3313        /// the e-mail is finally verified
3314        StatusVerified = 2,
3315    }
3316    impl EmailVerificationStatus {
3317        /// String value of the enum field names used in the ProtoBuf definition.
3318        ///
3319        /// The values are not transformed in any way and thus are considered stable
3320        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3321        pub fn as_str_name(&self) -> &'static str {
3322            match self {
3323                Self::StatusNotVerified => "StatusNotVerified",
3324                Self::StatusCodeSent => "StatusCodeSent",
3325                Self::StatusVerified => "StatusVerified",
3326            }
3327        }
3328        /// Creates an enum from field names used in the ProtoBuf definition.
3329        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3330            match value {
3331                "StatusNotVerified" => Some(Self::StatusNotVerified),
3332                "StatusCodeSent" => Some(Self::StatusCodeSent),
3333                "StatusVerified" => Some(Self::StatusVerified),
3334                _ => None,
3335            }
3336        }
3337    }
3338}
3339#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
3340pub struct MembershipTierData {
3341    /// this is a unique Payment Node ID of the tier
3342    /// WARNING: tiers can be sorted differently, not according to their IDs!
3343    #[prost(uint32, tag = "1")]
3344    pub id: u32,
3345    /// localazied name of the tier
3346    #[prost(string, tag = "2")]
3347    pub name: ::prost::alloc::string::String,
3348    /// just a short technical description
3349    #[prost(string, tag = "3")]
3350    pub description: ::prost::alloc::string::String,
3351    /// is this tier for testing and debugging only?
3352    #[prost(bool, tag = "4")]
3353    pub is_test: bool,
3354    /// how long is the period of the subscription
3355    #[prost(enumeration = "membership_tier_data::PeriodType", tag = "5")]
3356    pub period_type: i32,
3357    /// i.e. "5 days" or "3 years"
3358    #[prost(uint32, tag = "6")]
3359    pub period_value: u32,
3360    /// this one is a price we use ONLY on Stripe platform
3361    #[prost(uint32, tag = "7")]
3362    pub price_stripe_usd_cents: u32,
3363    /// number of ANY NS names that this tier includes
3364    /// also in the "features" list (see below)
3365    #[prost(uint32, tag = "8")]
3366    pub any_names_count_included: u32,
3367    /// somename.any - is of len 8
3368    #[prost(uint32, tag = "9")]
3369    pub any_name_min_length: u32,
3370    /// localized strings for the features
3371    #[prost(string, repeated, tag = "10")]
3372    pub features: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3373    /// green, blue, red, purple, custom
3374    #[prost(string, tag = "11")]
3375    pub color_str: ::prost::alloc::string::String,
3376    /// Stripe platform-specific data:
3377    #[prost(string, tag = "12")]
3378    pub stripe_product_id: ::prost::alloc::string::String,
3379    #[prost(string, tag = "13")]
3380    pub stripe_manage_url: ::prost::alloc::string::String,
3381    /// iOS platform-specific data:
3382    #[prost(string, tag = "15")]
3383    pub ios_product_id: ::prost::alloc::string::String,
3384    #[prost(string, tag = "16")]
3385    pub ios_manage_url: ::prost::alloc::string::String,
3386    /// Android platform-specific data:
3387    #[prost(string, tag = "17")]
3388    pub android_product_id: ::prost::alloc::string::String,
3389    #[prost(string, tag = "18")]
3390    pub android_manage_url: ::prost::alloc::string::String,
3391    /// "limited offer" or somehing like that
3392    #[prost(string, tag = "19")]
3393    pub offer: ::prost::alloc::string::String,
3394}
3395/// Nested message and enum types in `MembershipTierData`.
3396pub mod membership_tier_data {
3397    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3398    #[repr(i32)]
3399    pub enum PeriodType {
3400        Unknown = 0,
3401        Unlimited = 1,
3402        Days = 2,
3403        Weeks = 3,
3404        Months = 4,
3405        Years = 5,
3406    }
3407    impl PeriodType {
3408        /// String value of the enum field names used in the ProtoBuf definition.
3409        ///
3410        /// The values are not transformed in any way and thus are considered stable
3411        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3412        pub fn as_str_name(&self) -> &'static str {
3413            match self {
3414                Self::Unknown => "PeriodTypeUnknown",
3415                Self::Unlimited => "PeriodTypeUnlimited",
3416                Self::Days => "PeriodTypeDays",
3417                Self::Weeks => "PeriodTypeWeeks",
3418                Self::Months => "PeriodTypeMonths",
3419                Self::Years => "PeriodTypeYears",
3420            }
3421        }
3422        /// Creates an enum from field names used in the ProtoBuf definition.
3423        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3424            match value {
3425                "PeriodTypeUnknown" => Some(Self::Unknown),
3426                "PeriodTypeUnlimited" => Some(Self::Unlimited),
3427                "PeriodTypeDays" => Some(Self::Days),
3428                "PeriodTypeWeeks" => Some(Self::Weeks),
3429                "PeriodTypeMonths" => Some(Self::Months),
3430                "PeriodTypeYears" => Some(Self::Years),
3431                _ => None,
3432            }
3433        }
3434    }
3435}
3436#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
3437pub struct MembershipV2 {}
3438/// Nested message and enum types in `MembershipV2`.
3439pub mod membership_v2 {
3440    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
3441    pub struct Amount {
3442        /// ISO 4217 currency code
3443        #[prost(string, tag = "1")]
3444        pub currency: ::prost::alloc::string::String,
3445        /// $0.01 = 1
3446        /// $1.00 = 100
3447        /// also supports negative amounts!
3448        /// some invoices can have negatice amount (refund)
3449        #[prost(int64, tag = "2")]
3450        pub amount_cents: i64,
3451    }
3452    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
3453    pub struct Invoice {
3454        #[prost(uint64, tag = "1")]
3455        pub date: u64,
3456        #[prost(message, optional, tag = "2")]
3457        pub total: ::core::option::Option<Amount>,
3458    }
3459    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
3460    pub struct Features {
3461        #[prost(uint64, tag = "1")]
3462        pub storage_bytes: u64,
3463        #[prost(uint32, tag = "2")]
3464        pub space_readers: u32,
3465        #[prost(uint32, tag = "3")]
3466        pub space_writers: u32,
3467        #[prost(uint32, tag = "4")]
3468        pub shared_spaces: u32,
3469        #[prost(uint32, tag = "5")]
3470        pub team_seats: u32,
3471        #[prost(uint32, tag = "6")]
3472        pub any_name_count: u32,
3473        #[prost(uint32, tag = "7")]
3474        pub any_name_min_len: u32,
3475        #[prost(uint32, tag = "8")]
3476        pub private_spaces: u32,
3477    }
3478    #[derive(Clone, PartialEq, ::prost::Message)]
3479    pub struct Product {
3480        #[prost(string, tag = "1")]
3481        pub id: ::prost::alloc::string::String,
3482        #[prost(string, tag = "2")]
3483        pub name: ::prost::alloc::string::String,
3484        #[prost(string, tag = "3")]
3485        pub description: ::prost::alloc::string::String,
3486        #[prost(bool, tag = "4")]
3487        pub is_top_level: bool,
3488        #[prost(bool, tag = "5")]
3489        pub is_hidden: bool,
3490        /// isIntro flag can be used as follows:
3491        ///
3492        ///    1. if current user's top level product has isIntro flag ->
3493        ///       then you'd rather show a FULL list of all products
3494        ///       to enable upgrading from CURRENT product
3495        ///    1. but if current user's top level product has no isIntro flag ->
3496        ///       then it means that this plan was aquired and user need to control it.
3497        ///       then show "second screen" to control that product instead
3498        #[prost(bool, tag = "6")]
3499        pub is_intro: bool,
3500        /// isUpgradeable can be used as follows:
3501        ///
3502        /// if current user's top level product has isUpgradeable flag ->
3503        /// show incentives to buy something else
3504        #[prost(bool, tag = "7")]
3505        pub is_upgradeable: bool,
3506        #[prost(message, repeated, tag = "8")]
3507        pub prices_yearly: ::prost::alloc::vec::Vec<Amount>,
3508        #[prost(message, repeated, tag = "9")]
3509        pub prices_monthly: ::prost::alloc::vec::Vec<Amount>,
3510        /// green, blue, red, purple, custom, etc
3511        #[prost(string, tag = "10")]
3512        pub color_str: ::prost::alloc::string::String,
3513        #[prost(string, tag = "11")]
3514        pub offer: ::prost::alloc::string::String,
3515        #[prost(message, optional, tag = "12")]
3516        pub features: ::core::option::Option<Features>,
3517    }
3518    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
3519    pub struct PurchaseInfo {
3520        #[prost(uint64, tag = "1")]
3521        pub date_started: u64,
3522        #[prost(uint64, tag = "2")]
3523        pub date_ends: u64,
3524        #[prost(bool, tag = "3")]
3525        pub is_auto_renew: bool,
3526        #[prost(enumeration = "Period", tag = "4")]
3527        pub period: i32,
3528    }
3529    #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
3530    pub struct ProductStatus {
3531        #[prost(enumeration = "product_status::Status", tag = "1")]
3532        pub status: i32,
3533    }
3534    /// Nested message and enum types in `ProductStatus`.
3535    pub mod product_status {
3536        #[derive(
3537            Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
3538        )]
3539        #[repr(i32)]
3540        pub enum Status {
3541            Unknown = 0,
3542            Pending = 1,
3543            Active = 2,
3544            PendingRequiresAnyNameAllocation = 3,
3545        }
3546        impl Status {
3547            /// String value of the enum field names used in the ProtoBuf definition.
3548            ///
3549            /// The values are not transformed in any way and thus are considered stable
3550            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3551            pub fn as_str_name(&self) -> &'static str {
3552                match self {
3553                    Self::Unknown => "StatusUnknown",
3554                    Self::Pending => "StatusPending",
3555                    Self::Active => "StatusActive",
3556                    Self::PendingRequiresAnyNameAllocation => {
3557                        "StatusPendingRequiresAnyNameAllocation"
3558                    }
3559                }
3560            }
3561            /// Creates an enum from field names used in the ProtoBuf definition.
3562            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3563                match value {
3564                    "StatusUnknown" => Some(Self::Unknown),
3565                    "StatusPending" => Some(Self::Pending),
3566                    "StatusActive" => Some(Self::Active),
3567                    "StatusPendingRequiresAnyNameAllocation" => {
3568                        Some(Self::PendingRequiresAnyNameAllocation)
3569                    }
3570                    _ => None,
3571                }
3572            }
3573        }
3574    }
3575    #[derive(Clone, PartialEq, ::prost::Message)]
3576    pub struct PurchasedProduct {
3577        #[prost(message, optional, tag = "1")]
3578        pub product: ::core::option::Option<Product>,
3579        #[prost(message, optional, tag = "2")]
3580        pub purchase_info: ::core::option::Option<PurchaseInfo>,
3581        #[prost(message, optional, tag = "3")]
3582        pub product_status: ::core::option::Option<ProductStatus>,
3583    }
3584    #[derive(Clone, PartialEq, ::prost::Message)]
3585    pub struct CartProduct {
3586        #[prost(message, optional, tag = "1")]
3587        pub product: ::core::option::Option<Product>,
3588        /// otherwise - monthly
3589        #[prost(bool, tag = "2")]
3590        pub is_yearly: bool,
3591        /// set to true if you want to remove this item from the customer
3592        /// it's like setting -1 to some product
3593        #[prost(bool, tag = "3")]
3594        pub remove: bool,
3595    }
3596    #[derive(Clone, PartialEq, ::prost::Message)]
3597    pub struct Cart {
3598        /// if you add Nx the same product - it will be Nx in the 'products' array, i.e:
3599        /// each product instance has a unique index
3600        #[prost(message, repeated, tag = "1")]
3601        pub products: ::prost::alloc::vec::Vec<CartProduct>,
3602        /// total amount of the cart (including discounts, etc)
3603        #[prost(message, optional, tag = "2")]
3604        pub total: ::core::option::Option<Amount>,
3605        /// in case you are paying in the middle of the period (for existing customers)
3606        /// the next invoice amount will also be generated
3607        #[prost(message, optional, tag = "3")]
3608        pub total_next_invoice: ::core::option::Option<Amount>,
3609        #[prost(uint64, tag = "4")]
3610        pub next_invoice_date: u64,
3611    }
3612    #[derive(Clone, PartialEq, ::prost::Message)]
3613    pub struct Data {
3614        #[prost(message, repeated, tag = "1")]
3615        pub products: ::prost::alloc::vec::Vec<PurchasedProduct>,
3616        #[prost(message, optional, tag = "2")]
3617        pub next_invoice: ::core::option::Option<Invoice>,
3618        #[prost(string, tag = "3")]
3619        pub team_owner_id: ::prost::alloc::string::String,
3620        #[prost(enumeration = "PaymentProvider", tag = "4")]
3621        pub payment_provider: i32,
3622    }
3623    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3624    #[repr(i32)]
3625    pub enum Platform {
3626        Unknown = 0,
3627        Desktop = 1,
3628        MobileIos = 2,
3629        MobileAndroid = 3,
3630        Web = 4,
3631    }
3632    impl Platform {
3633        /// String value of the enum field names used in the ProtoBuf definition.
3634        ///
3635        /// The values are not transformed in any way and thus are considered stable
3636        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3637        pub fn as_str_name(&self) -> &'static str {
3638            match self {
3639                Self::Unknown => "Unknown",
3640                Self::Desktop => "Desktop",
3641                Self::MobileIos => "MobileIOS",
3642                Self::MobileAndroid => "MobileAndroid",
3643                Self::Web => "Web",
3644            }
3645        }
3646        /// Creates an enum from field names used in the ProtoBuf definition.
3647        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3648            match value {
3649                "Unknown" => Some(Self::Unknown),
3650                "Desktop" => Some(Self::Desktop),
3651                "MobileIOS" => Some(Self::MobileIos),
3652                "MobileAndroid" => Some(Self::MobileAndroid),
3653                "Web" => Some(Self::Web),
3654                _ => None,
3655            }
3656        }
3657    }
3658    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3659    #[repr(i32)]
3660    pub enum PaymentProvider {
3661        None = 0,
3662        Stripe = 1,
3663        Crypto = 2,
3664        BillingPortal = 3,
3665        AppStore = 4,
3666        GooglePlay = 5,
3667    }
3668    impl PaymentProvider {
3669        /// String value of the enum field names used in the ProtoBuf definition.
3670        ///
3671        /// The values are not transformed in any way and thus are considered stable
3672        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3673        pub fn as_str_name(&self) -> &'static str {
3674            match self {
3675                Self::None => "None",
3676                Self::Stripe => "Stripe",
3677                Self::Crypto => "Crypto",
3678                Self::BillingPortal => "BillingPortal",
3679                Self::AppStore => "AppStore",
3680                Self::GooglePlay => "GooglePlay",
3681            }
3682        }
3683        /// Creates an enum from field names used in the ProtoBuf definition.
3684        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3685            match value {
3686                "None" => Some(Self::None),
3687                "Stripe" => Some(Self::Stripe),
3688                "Crypto" => Some(Self::Crypto),
3689                "BillingPortal" => Some(Self::BillingPortal),
3690                "AppStore" => Some(Self::AppStore),
3691                "GooglePlay" => Some(Self::GooglePlay),
3692                _ => None,
3693            }
3694        }
3695    }
3696    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3697    #[repr(i32)]
3698    pub enum Period {
3699        Unlimited = 0,
3700        Monthly = 1,
3701        Yearly = 2,
3702        ThreeYears = 3,
3703    }
3704    impl Period {
3705        /// String value of the enum field names used in the ProtoBuf definition.
3706        ///
3707        /// The values are not transformed in any way and thus are considered stable
3708        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3709        pub fn as_str_name(&self) -> &'static str {
3710            match self {
3711                Self::Unlimited => "Unlimited",
3712                Self::Monthly => "Monthly",
3713                Self::Yearly => "Yearly",
3714                Self::ThreeYears => "ThreeYears",
3715            }
3716        }
3717        /// Creates an enum from field names used in the ProtoBuf definition.
3718        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3719            match value {
3720                "Unlimited" => Some(Self::Unlimited),
3721                "Monthly" => Some(Self::Monthly),
3722                "Yearly" => Some(Self::Yearly),
3723                "ThreeYears" => Some(Self::ThreeYears),
3724                _ => None,
3725            }
3726        }
3727    }
3728}
3729#[derive(Clone, PartialEq, ::prost::Message)]
3730pub struct Detail {
3731    #[prost(string, tag = "1")]
3732    pub key: ::prost::alloc::string::String,
3733    /// NUll - removes key
3734    #[prost(message, optional, tag = "2")]
3735    pub value: ::core::option::Option<::prost_types::Value>,
3736}
3737#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
3738pub struct DeviceInfo {
3739    #[prost(string, tag = "1")]
3740    pub id: ::prost::alloc::string::String,
3741    #[prost(string, tag = "2")]
3742    pub name: ::prost::alloc::string::String,
3743    #[prost(int64, tag = "3")]
3744    pub add_date: i64,
3745    #[prost(bool, tag = "4")]
3746    pub archived: bool,
3747    #[prost(bool, tag = "5")]
3748    pub is_connected: bool,
3749}
3750#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
3751pub struct ChatState {
3752    /// unread messages
3753    #[prost(message, optional, tag = "1")]
3754    pub messages: ::core::option::Option<chat_state::UnreadState>,
3755    /// unread mentions
3756    #[prost(message, optional, tag = "2")]
3757    pub mentions: ::core::option::Option<chat_state::UnreadState>,
3758    /// reflects the state of the chat db at the moment of sending response/event that includes this state
3759    #[prost(string, tag = "3")]
3760    pub last_state_id: ::prost::alloc::string::String,
3761    /// Order is serial number of this state. Client should apply chat state only if its order is greater than previously saved order
3762    #[prost(int64, tag = "4")]
3763    pub order: i64,
3764}
3765/// Nested message and enum types in `ChatState`.
3766pub mod chat_state {
3767    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
3768    pub struct UnreadState {
3769        /// oldest(in the lex sorting) unread message order id. Client should ALWAYS scroll through unread messages from the oldest to the newest
3770        #[prost(string, tag = "1")]
3771        pub oldest_order_id: ::prost::alloc::string::String,
3772        /// total number of unread messages
3773        #[prost(int32, tag = "2")]
3774        pub counter: i32,
3775    }
3776}
3777#[derive(Clone, PartialEq, ::prost::Message)]
3778pub struct ChatMessage {
3779    /// Unique message identifier
3780    #[prost(string, tag = "1")]
3781    pub id: ::prost::alloc::string::String,
3782    /// Lexicographical id for message in order of tree traversal
3783    #[prost(string, tag = "2")]
3784    pub order_id: ::prost::alloc::string::String,
3785    /// Identifier for the message creator
3786    #[prost(string, tag = "3")]
3787    pub creator: ::prost::alloc::string::String,
3788    #[prost(int64, tag = "4")]
3789    pub created_at: i64,
3790    #[prost(int64, tag = "9")]
3791    pub modified_at: i64,
3792    /// stateId is ever-increasing id (BSON ObjectId) for this message. Unlike orderId, this ID is ordered by the time messages are added. For example, it's useful to prevent accidental reading of messages from the past when a ChatReadMessages request is sent: a message from the past may appear, but the client is still unaware of it
3793    #[prost(string, tag = "11")]
3794    pub state_id: ::prost::alloc::string::String,
3795    /// Identifier for the message being replied to
3796    #[prost(string, tag = "5")]
3797    pub reply_to_message_id: ::prost::alloc::string::String,
3798    /// Message content
3799    #[prost(message, optional, tag = "6")]
3800    pub message: ::core::option::Option<chat_message::MessageContent>,
3801    /// Attachments slice
3802    #[prost(message, repeated, tag = "7")]
3803    pub attachments: ::prost::alloc::vec::Vec<chat_message::Attachment>,
3804    /// Reactions to the message
3805    #[prost(message, optional, tag = "8")]
3806    pub reactions: ::core::option::Option<chat_message::Reactions>,
3807    /// Message read status
3808    #[prost(bool, tag = "10")]
3809    pub read: bool,
3810    #[prost(bool, tag = "12")]
3811    pub mention_read: bool,
3812    #[prost(bool, tag = "14")]
3813    pub has_mention: bool,
3814    #[prost(bool, tag = "13")]
3815    pub synced: bool,
3816}
3817/// Nested message and enum types in `ChatMessage`.
3818pub mod chat_message {
3819    #[derive(Clone, PartialEq, ::prost::Message)]
3820    pub struct MessageContent {
3821        /// The text content of the message part
3822        #[prost(string, tag = "1")]
3823        pub text: ::prost::alloc::string::String,
3824        /// The style/type of the message part
3825        #[prost(enumeration = "super::block::content::text::Style", tag = "2")]
3826        pub style: i32,
3827        /// List of marks applied to the text
3828        #[prost(message, repeated, tag = "3")]
3829        pub marks: ::prost::alloc::vec::Vec<super::block::content::text::Mark>,
3830    }
3831    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
3832    pub struct Attachment {
3833        /// Identifier for the attachment object
3834        #[prost(string, tag = "1")]
3835        pub target: ::prost::alloc::string::String,
3836        /// Type of attachment
3837        #[prost(enumeration = "attachment::AttachmentType", tag = "2")]
3838        pub r#type: i32,
3839    }
3840    /// Nested message and enum types in `Attachment`.
3841    pub mod attachment {
3842        #[derive(
3843            Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration,
3844        )]
3845        #[repr(i32)]
3846        pub enum AttachmentType {
3847            /// File attachment
3848            File = 0,
3849            /// Image attachment
3850            Image = 1,
3851            /// Link attachment
3852            Link = 2,
3853        }
3854        impl AttachmentType {
3855            /// String value of the enum field names used in the ProtoBuf definition.
3856            ///
3857            /// The values are not transformed in any way and thus are considered stable
3858            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3859            pub fn as_str_name(&self) -> &'static str {
3860                match self {
3861                    Self::File => "FILE",
3862                    Self::Image => "IMAGE",
3863                    Self::Link => "LINK",
3864                }
3865            }
3866            /// Creates an enum from field names used in the ProtoBuf definition.
3867            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3868                match value {
3869                    "FILE" => Some(Self::File),
3870                    "IMAGE" => Some(Self::Image),
3871                    "LINK" => Some(Self::Link),
3872                    _ => None,
3873                }
3874            }
3875        }
3876    }
3877    #[derive(Clone, PartialEq, ::prost::Message)]
3878    pub struct Reactions {
3879        /// Map of emoji to list of user IDs
3880        #[prost(map = "string, message", tag = "1")]
3881        pub reactions:
3882            ::std::collections::HashMap<::prost::alloc::string::String, reactions::IdentityList>,
3883    }
3884    /// Nested message and enum types in `Reactions`.
3885    pub mod reactions {
3886        #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
3887        pub struct IdentityList {
3888            /// List of user IDs
3889            #[prost(string, repeated, tag = "1")]
3890            pub ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
3891        }
3892    }
3893}
3894#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
3895#[repr(i32)]
3896pub enum SmartBlockType {
3897    /// deprecated
3898    AccountOld = 0,
3899    Page = 16,
3900    ProfilePage = 17,
3901    Home = 32,
3902    Archive = 48,
3903    Widget = 112,
3904    File = 256,
3905    Template = 288,
3906    BundledTemplate = 289,
3907    /// DEPRECATED
3908    BundledRelation = 512,
3909    SubObject = 513,
3910    /// DEPRECATED
3911    BundledObjectType = 514,
3912    AnytypeProfile = 515,
3913    Date = 516,
3914    Workspace = 518,
3915    StRelation = 521,
3916    StType = 528,
3917    StRelationOption = 529,
3918    SpaceView = 530,
3919    Identity = 532,
3920    Participant = 534,
3921    MissingObject = 519,
3922    FileObject = 533,
3923    NotificationObject = 535,
3924    DevicesObject = 536,
3925    /// DEPRECATED Container for any-store based chats
3926    ChatObjectDeprecated = 537,
3927    /// Any-store based object for chat
3928    ChatDerivedObject = 544,
3929    /// Container for account data in tech space
3930    AccountObject = 545,
3931}
3932impl SmartBlockType {
3933    /// String value of the enum field names used in the ProtoBuf definition.
3934    ///
3935    /// The values are not transformed in any way and thus are considered stable
3936    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
3937    pub fn as_str_name(&self) -> &'static str {
3938        match self {
3939            Self::AccountOld => "AccountOld",
3940            Self::Page => "Page",
3941            Self::ProfilePage => "ProfilePage",
3942            Self::Home => "Home",
3943            Self::Archive => "Archive",
3944            Self::Widget => "Widget",
3945            Self::File => "File",
3946            Self::Template => "Template",
3947            Self::BundledTemplate => "BundledTemplate",
3948            Self::BundledRelation => "BundledRelation",
3949            Self::SubObject => "SubObject",
3950            Self::BundledObjectType => "BundledObjectType",
3951            Self::AnytypeProfile => "AnytypeProfile",
3952            Self::Date => "Date",
3953            Self::Workspace => "Workspace",
3954            Self::StRelation => "STRelation",
3955            Self::StType => "STType",
3956            Self::StRelationOption => "STRelationOption",
3957            Self::SpaceView => "SpaceView",
3958            Self::Identity => "Identity",
3959            Self::Participant => "Participant",
3960            Self::MissingObject => "MissingObject",
3961            Self::FileObject => "FileObject",
3962            Self::NotificationObject => "NotificationObject",
3963            Self::DevicesObject => "DevicesObject",
3964            Self::ChatObjectDeprecated => "ChatObjectDeprecated",
3965            Self::ChatDerivedObject => "ChatDerivedObject",
3966            Self::AccountObject => "AccountObject",
3967        }
3968    }
3969    /// Creates an enum from field names used in the ProtoBuf definition.
3970    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
3971        match value {
3972            "AccountOld" => Some(Self::AccountOld),
3973            "Page" => Some(Self::Page),
3974            "ProfilePage" => Some(Self::ProfilePage),
3975            "Home" => Some(Self::Home),
3976            "Archive" => Some(Self::Archive),
3977            "Widget" => Some(Self::Widget),
3978            "File" => Some(Self::File),
3979            "Template" => Some(Self::Template),
3980            "BundledTemplate" => Some(Self::BundledTemplate),
3981            "BundledRelation" => Some(Self::BundledRelation),
3982            "SubObject" => Some(Self::SubObject),
3983            "BundledObjectType" => Some(Self::BundledObjectType),
3984            "AnytypeProfile" => Some(Self::AnytypeProfile),
3985            "Date" => Some(Self::Date),
3986            "Workspace" => Some(Self::Workspace),
3987            "STRelation" => Some(Self::StRelation),
3988            "STType" => Some(Self::StType),
3989            "STRelationOption" => Some(Self::StRelationOption),
3990            "SpaceView" => Some(Self::SpaceView),
3991            "Identity" => Some(Self::Identity),
3992            "Participant" => Some(Self::Participant),
3993            "MissingObject" => Some(Self::MissingObject),
3994            "FileObject" => Some(Self::FileObject),
3995            "NotificationObject" => Some(Self::NotificationObject),
3996            "DevicesObject" => Some(Self::DevicesObject),
3997            "ChatObjectDeprecated" => Some(Self::ChatObjectDeprecated),
3998            "ChatDerivedObject" => Some(Self::ChatDerivedObject),
3999            "AccountObject" => Some(Self::AccountObject),
4000            _ => None,
4001        }
4002    }
4003}
4004/// RelationFormat describes how the underlying data is stored in the google.protobuf.Value and how it should be validated/sanitized
4005#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4006#[repr(i32)]
4007pub enum RelationFormat {
4008    /// string
4009    Longtext = 0,
4010    /// string, usually short enough. May be truncated in the future
4011    Shorttext = 1,
4012    /// double
4013    Number = 2,
4014    /// string or list of string(len==1)
4015    Status = 3,
4016    /// list of string (choose multiple from a list)
4017    Tag = 11,
4018    /// float64(pb.Value doesn't have int64) or the string
4019    Date = 4,
4020    /// relation can has objects of specific types: file, image, audio, video
4021    File = 5,
4022    /// boolean
4023    Checkbox = 6,
4024    /// string with sanity check
4025    Url = 7,
4026    /// string with sanity check
4027    Email = 8,
4028    /// string with sanity check
4029    Phone = 9,
4030    /// one emoji, can contains multiple utf-8 symbols
4031    Emoji = 10,
4032    /// relation can has objectType to specify objectType
4033    Object = 100,
4034    /// base64-encoded relation pb model
4035    Relations = 101,
4036}
4037impl RelationFormat {
4038    /// String value of the enum field names used in the ProtoBuf definition.
4039    ///
4040    /// The values are not transformed in any way and thus are considered stable
4041    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4042    pub fn as_str_name(&self) -> &'static str {
4043        match self {
4044            Self::Longtext => "longtext",
4045            Self::Shorttext => "shorttext",
4046            Self::Number => "number",
4047            Self::Status => "status",
4048            Self::Tag => "tag",
4049            Self::Date => "date",
4050            Self::File => "file",
4051            Self::Checkbox => "checkbox",
4052            Self::Url => "url",
4053            Self::Email => "email",
4054            Self::Phone => "phone",
4055            Self::Emoji => "emoji",
4056            Self::Object => "object",
4057            Self::Relations => "relations",
4058        }
4059    }
4060    /// Creates an enum from field names used in the ProtoBuf definition.
4061    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4062        match value {
4063            "longtext" => Some(Self::Longtext),
4064            "shorttext" => Some(Self::Shorttext),
4065            "number" => Some(Self::Number),
4066            "status" => Some(Self::Status),
4067            "tag" => Some(Self::Tag),
4068            "date" => Some(Self::Date),
4069            "file" => Some(Self::File),
4070            "checkbox" => Some(Self::Checkbox),
4071            "url" => Some(Self::Url),
4072            "email" => Some(Self::Email),
4073            "phone" => Some(Self::Phone),
4074            "emoji" => Some(Self::Emoji),
4075            "object" => Some(Self::Object),
4076            "relations" => Some(Self::Relations),
4077            _ => None,
4078        }
4079    }
4080}
4081#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4082#[repr(i32)]
4083pub enum ObjectOrigin {
4084    None = 0,
4085    Clipboard = 1,
4086    DragAndDrop = 2,
4087    Import = 3,
4088    Webclipper = 4,
4089    SharingExtension = 5,
4090    Usecase = 6,
4091    Builtin = 7,
4092    Bookmark = 8,
4093    Api = 9,
4094}
4095impl ObjectOrigin {
4096    /// String value of the enum field names used in the ProtoBuf definition.
4097    ///
4098    /// The values are not transformed in any way and thus are considered stable
4099    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4100    pub fn as_str_name(&self) -> &'static str {
4101        match self {
4102            Self::None => "none",
4103            Self::Clipboard => "clipboard",
4104            Self::DragAndDrop => "dragAndDrop",
4105            Self::Import => "import",
4106            Self::Webclipper => "webclipper",
4107            Self::SharingExtension => "sharingExtension",
4108            Self::Usecase => "usecase",
4109            Self::Builtin => "builtin",
4110            Self::Bookmark => "bookmark",
4111            Self::Api => "api",
4112        }
4113    }
4114    /// Creates an enum from field names used in the ProtoBuf definition.
4115    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4116        match value {
4117            "none" => Some(Self::None),
4118            "clipboard" => Some(Self::Clipboard),
4119            "dragAndDrop" => Some(Self::DragAndDrop),
4120            "import" => Some(Self::Import),
4121            "webclipper" => Some(Self::Webclipper),
4122            "sharingExtension" => Some(Self::SharingExtension),
4123            "usecase" => Some(Self::Usecase),
4124            "builtin" => Some(Self::Builtin),
4125            "bookmark" => Some(Self::Bookmark),
4126            "api" => Some(Self::Api),
4127            _ => None,
4128        }
4129    }
4130}
4131#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4132#[repr(i32)]
4133pub enum SpaceStatus {
4134    /// Unknown means the space is not loaded yet
4135    Unknown = 0,
4136    /// Loading - the space in progress of loading
4137    Loading = 1,
4138    /// Ok - the space loaded and available
4139    Ok = 2,
4140    /// Missing - the space is missing
4141    Missing = 3,
4142    /// Error - the space loading ended with an error
4143    Error = 4,
4144    /// RemoteWaitingDeletion - network status is "waiting deletion"
4145    RemoteWaitingDeletion = 5,
4146    /// RemoteDeleted - the space is deleted in the current network
4147    RemoteDeleted = 6,
4148    /// SpaceDeleted - the space should be deleted in the network
4149    SpaceDeleted = 7,
4150    /// SpaceActive - the space is active in the network
4151    SpaceActive = 8,
4152    /// SpaceJoining - the account is joining the space
4153    SpaceJoining = 9,
4154    /// SpaceRemoving - the account is removing from space or the space is removed from network
4155    SpaceRemoving = 10,
4156}
4157impl SpaceStatus {
4158    /// String value of the enum field names used in the ProtoBuf definition.
4159    ///
4160    /// The values are not transformed in any way and thus are considered stable
4161    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4162    pub fn as_str_name(&self) -> &'static str {
4163        match self {
4164            Self::Unknown => "Unknown",
4165            Self::Loading => "Loading",
4166            Self::Ok => "Ok",
4167            Self::Missing => "Missing",
4168            Self::Error => "Error",
4169            Self::RemoteWaitingDeletion => "RemoteWaitingDeletion",
4170            Self::RemoteDeleted => "RemoteDeleted",
4171            Self::SpaceDeleted => "SpaceDeleted",
4172            Self::SpaceActive => "SpaceActive",
4173            Self::SpaceJoining => "SpaceJoining",
4174            Self::SpaceRemoving => "SpaceRemoving",
4175        }
4176    }
4177    /// Creates an enum from field names used in the ProtoBuf definition.
4178    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4179        match value {
4180            "Unknown" => Some(Self::Unknown),
4181            "Loading" => Some(Self::Loading),
4182            "Ok" => Some(Self::Ok),
4183            "Missing" => Some(Self::Missing),
4184            "Error" => Some(Self::Error),
4185            "RemoteWaitingDeletion" => Some(Self::RemoteWaitingDeletion),
4186            "RemoteDeleted" => Some(Self::RemoteDeleted),
4187            "SpaceDeleted" => Some(Self::SpaceDeleted),
4188            "SpaceActive" => Some(Self::SpaceActive),
4189            "SpaceJoining" => Some(Self::SpaceJoining),
4190            "SpaceRemoving" => Some(Self::SpaceRemoving),
4191            _ => None,
4192        }
4193    }
4194}
4195#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4196#[repr(i32)]
4197pub enum ParticipantPermissions {
4198    Reader = 0,
4199    Writer = 1,
4200    Owner = 2,
4201    NoPermissions = 3,
4202}
4203impl ParticipantPermissions {
4204    /// String value of the enum field names used in the ProtoBuf definition.
4205    ///
4206    /// The values are not transformed in any way and thus are considered stable
4207    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4208    pub fn as_str_name(&self) -> &'static str {
4209        match self {
4210            Self::Reader => "Reader",
4211            Self::Writer => "Writer",
4212            Self::Owner => "Owner",
4213            Self::NoPermissions => "NoPermissions",
4214        }
4215    }
4216    /// Creates an enum from field names used in the ProtoBuf definition.
4217    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4218        match value {
4219            "Reader" => Some(Self::Reader),
4220            "Writer" => Some(Self::Writer),
4221            "Owner" => Some(Self::Owner),
4222            "NoPermissions" => Some(Self::NoPermissions),
4223            _ => None,
4224        }
4225    }
4226}
4227#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4228#[repr(i32)]
4229pub enum InviteType {
4230    /// aclKey contains the key to sign the ACL record
4231    Member = 0,
4232    /// guestKey contains the privateKey of the guest user
4233    Guest = 1,
4234    /// aclKey contains the key to sign the ACL record, but no approval needed
4235    WithoutApprove = 2,
4236}
4237impl InviteType {
4238    /// String value of the enum field names used in the ProtoBuf definition.
4239    ///
4240    /// The values are not transformed in any way and thus are considered stable
4241    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4242    pub fn as_str_name(&self) -> &'static str {
4243        match self {
4244            Self::Member => "Member",
4245            Self::Guest => "Guest",
4246            Self::WithoutApprove => "WithoutApprove",
4247        }
4248    }
4249    /// Creates an enum from field names used in the ProtoBuf definition.
4250    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4251        match value {
4252            "Member" => Some(Self::Member),
4253            "Guest" => Some(Self::Guest),
4254            "WithoutApprove" => Some(Self::WithoutApprove),
4255            _ => None,
4256        }
4257    }
4258}
4259#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4260#[repr(i32)]
4261pub enum ParticipantStatus {
4262    Joining = 0,
4263    Active = 1,
4264    Removed = 2,
4265    Declined = 3,
4266    Removing = 4,
4267    Canceled = 5,
4268}
4269impl ParticipantStatus {
4270    /// String value of the enum field names used in the ProtoBuf definition.
4271    ///
4272    /// The values are not transformed in any way and thus are considered stable
4273    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4274    pub fn as_str_name(&self) -> &'static str {
4275        match self {
4276            Self::Joining => "Joining",
4277            Self::Active => "Active",
4278            Self::Removed => "Removed",
4279            Self::Declined => "Declined",
4280            Self::Removing => "Removing",
4281            Self::Canceled => "Canceled",
4282        }
4283    }
4284    /// Creates an enum from field names used in the ProtoBuf definition.
4285    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4286        match value {
4287            "Joining" => Some(Self::Joining),
4288            "Active" => Some(Self::Active),
4289            "Removed" => Some(Self::Removed),
4290            "Declined" => Some(Self::Declined),
4291            "Removing" => Some(Self::Removing),
4292            "Canceled" => Some(Self::Canceled),
4293            _ => None,
4294        }
4295    }
4296}
4297#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4298#[repr(i32)]
4299pub enum SpaceAccessType {
4300    Private = 0,
4301    Personal = 1,
4302    Shared = 2,
4303}
4304impl SpaceAccessType {
4305    /// String value of the enum field names used in the ProtoBuf definition.
4306    ///
4307    /// The values are not transformed in any way and thus are considered stable
4308    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4309    pub fn as_str_name(&self) -> &'static str {
4310        match self {
4311            Self::Private => "Private",
4312            Self::Personal => "Personal",
4313            Self::Shared => "Shared",
4314        }
4315    }
4316    /// Creates an enum from field names used in the ProtoBuf definition.
4317    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4318        match value {
4319            "Private" => Some(Self::Private),
4320            "Personal" => Some(Self::Personal),
4321            "Shared" => Some(Self::Shared),
4322            _ => None,
4323        }
4324    }
4325}
4326#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4327#[repr(i32)]
4328pub enum SpaceUxType {
4329    /// old value for chat, deprecated
4330    None = 0,
4331    /// objects-first UX
4332    Data = 1,
4333    /// stream UX (chat with limited amount of owners)
4334    Stream = 2,
4335    /// chat UX
4336    Chat = 3,
4337    /// onetoone UX (space with chat and immutable ACL between two participants)
4338    OneToOne = 4,
4339}
4340impl SpaceUxType {
4341    /// String value of the enum field names used in the ProtoBuf definition.
4342    ///
4343    /// The values are not transformed in any way and thus are considered stable
4344    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4345    pub fn as_str_name(&self) -> &'static str {
4346        match self {
4347            Self::None => "None",
4348            Self::Data => "Data",
4349            Self::Stream => "Stream",
4350            Self::Chat => "Chat",
4351            Self::OneToOne => "OneToOne",
4352        }
4353    }
4354    /// Creates an enum from field names used in the ProtoBuf definition.
4355    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4356        match value {
4357            "None" => Some(Self::None),
4358            "Data" => Some(Self::Data),
4359            "Stream" => Some(Self::Stream),
4360            "Chat" => Some(Self::Chat),
4361            "OneToOne" => Some(Self::OneToOne),
4362            _ => None,
4363        }
4364    }
4365}
4366#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4367#[repr(i32)]
4368pub enum ImageKind {
4369    Basic = 0,
4370    Cover = 1,
4371    Icon = 2,
4372    AutomaticallyAdded = 3,
4373}
4374impl ImageKind {
4375    /// String value of the enum field names used in the ProtoBuf definition.
4376    ///
4377    /// The values are not transformed in any way and thus are considered stable
4378    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4379    pub fn as_str_name(&self) -> &'static str {
4380        match self {
4381            Self::Basic => "Basic",
4382            Self::Cover => "Cover",
4383            Self::Icon => "Icon",
4384            Self::AutomaticallyAdded => "AutomaticallyAdded",
4385        }
4386    }
4387    /// Creates an enum from field names used in the ProtoBuf definition.
4388    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4389        match value {
4390            "Basic" => Some(Self::Basic),
4391            "Cover" => Some(Self::Cover),
4392            "Icon" => Some(Self::Icon),
4393            "AutomaticallyAdded" => Some(Self::AutomaticallyAdded),
4394            _ => None,
4395        }
4396    }
4397}
4398#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4399#[repr(i32)]
4400pub enum FileIndexingStatus {
4401    NotIndexed = 0,
4402    Indexed = 1,
4403    NotFound = 2,
4404}
4405impl FileIndexingStatus {
4406    /// String value of the enum field names used in the ProtoBuf definition.
4407    ///
4408    /// The values are not transformed in any way and thus are considered stable
4409    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4410    pub fn as_str_name(&self) -> &'static str {
4411        match self {
4412            Self::NotIndexed => "NotIndexed",
4413            Self::Indexed => "Indexed",
4414            Self::NotFound => "NotFound",
4415        }
4416    }
4417    /// Creates an enum from field names used in the ProtoBuf definition.
4418    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4419        match value {
4420            "NotIndexed" => Some(Self::NotIndexed),
4421            "Indexed" => Some(Self::Indexed),
4422            "NotFound" => Some(Self::NotFound),
4423            _ => None,
4424        }
4425    }
4426}
4427#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4428#[repr(i32)]
4429pub enum SpaceShareableStatus {
4430    StatusUnknown = 0,
4431    StatusShareable = 1,
4432    StatusNotShareable = 2,
4433}
4434impl SpaceShareableStatus {
4435    /// String value of the enum field names used in the ProtoBuf definition.
4436    ///
4437    /// The values are not transformed in any way and thus are considered stable
4438    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4439    pub fn as_str_name(&self) -> &'static str {
4440        match self {
4441            Self::StatusUnknown => "StatusUnknown",
4442            Self::StatusShareable => "StatusShareable",
4443            Self::StatusNotShareable => "StatusNotShareable",
4444        }
4445    }
4446    /// Creates an enum from field names used in the ProtoBuf definition.
4447    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4448        match value {
4449            "StatusUnknown" => Some(Self::StatusUnknown),
4450            "StatusShareable" => Some(Self::StatusShareable),
4451            "StatusNotShareable" => Some(Self::StatusNotShareable),
4452            _ => None,
4453        }
4454    }
4455}
4456#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4457#[repr(i32)]
4458pub enum NameserviceNameType {
4459    /// .any suffix
4460    AnyName = 0,
4461}
4462impl NameserviceNameType {
4463    /// String value of the enum field names used in the ProtoBuf definition.
4464    ///
4465    /// The values are not transformed in any way and thus are considered stable
4466    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4467    pub fn as_str_name(&self) -> &'static str {
4468        match self {
4469            Self::AnyName => "AnyName",
4470        }
4471    }
4472    /// Creates an enum from field names used in the ProtoBuf definition.
4473    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4474        match value {
4475            "AnyName" => Some(Self::AnyName),
4476            _ => None,
4477        }
4478    }
4479}
4480#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4481#[repr(i32)]
4482pub enum DeviceNetworkType {
4483    Wifi = 0,
4484    Cellular = 1,
4485    NotConnected = 2,
4486}
4487impl DeviceNetworkType {
4488    /// String value of the enum field names used in the ProtoBuf definition.
4489    ///
4490    /// The values are not transformed in any way and thus are considered stable
4491    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4492    pub fn as_str_name(&self) -> &'static str {
4493        match self {
4494            Self::Wifi => "WIFI",
4495            Self::Cellular => "CELLULAR",
4496            Self::NotConnected => "NOT_CONNECTED",
4497        }
4498    }
4499    /// Creates an enum from field names used in the ProtoBuf definition.
4500    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4501        match value {
4502            "WIFI" => Some(Self::Wifi),
4503            "CELLULAR" => Some(Self::Cellular),
4504            "NOT_CONNECTED" => Some(Self::NotConnected),
4505            _ => None,
4506        }
4507    }
4508}
4509#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4510#[repr(i32)]
4511pub enum SyncStatus {
4512    Synced = 0,
4513    Syncing = 1,
4514    Error = 2,
4515    Queued = 3,
4516}
4517impl SyncStatus {
4518    /// String value of the enum field names used in the ProtoBuf definition.
4519    ///
4520    /// The values are not transformed in any way and thus are considered stable
4521    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4522    pub fn as_str_name(&self) -> &'static str {
4523        match self {
4524            Self::Synced => "SyncStatusSynced",
4525            Self::Syncing => "SyncStatusSyncing",
4526            Self::Error => "SyncStatusError",
4527            Self::Queued => "SyncStatusQueued",
4528        }
4529    }
4530    /// Creates an enum from field names used in the ProtoBuf definition.
4531    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4532        match value {
4533            "SyncStatusSynced" => Some(Self::Synced),
4534            "SyncStatusSyncing" => Some(Self::Syncing),
4535            "SyncStatusError" => Some(Self::Error),
4536            "SyncStatusQueued" => Some(Self::Queued),
4537            _ => None,
4538        }
4539    }
4540}
4541#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4542#[repr(i32)]
4543pub enum SyncError {
4544    Null = 0,
4545    IncompatibleVersion = 2,
4546    NetworkError = 3,
4547    Oversized = 4,
4548}
4549impl SyncError {
4550    /// String value of the enum field names used in the ProtoBuf definition.
4551    ///
4552    /// The values are not transformed in any way and thus are considered stable
4553    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4554    pub fn as_str_name(&self) -> &'static str {
4555        match self {
4556            Self::Null => "SyncErrorNull",
4557            Self::IncompatibleVersion => "SyncErrorIncompatibleVersion",
4558            Self::NetworkError => "SyncErrorNetworkError",
4559            Self::Oversized => "SyncErrorOversized",
4560        }
4561    }
4562    /// Creates an enum from field names used in the ProtoBuf definition.
4563    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4564        match value {
4565            "SyncErrorNull" => Some(Self::Null),
4566            "SyncErrorIncompatibleVersion" => Some(Self::IncompatibleVersion),
4567            "SyncErrorNetworkError" => Some(Self::NetworkError),
4568            "SyncErrorOversized" => Some(Self::Oversized),
4569            _ => None,
4570        }
4571    }
4572}
4573#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
4574#[repr(i32)]
4575pub enum TemplateNamePrefillType {
4576    Empty = 0,
4577    FromTemplateName = 1,
4578}
4579impl TemplateNamePrefillType {
4580    /// String value of the enum field names used in the ProtoBuf definition.
4581    ///
4582    /// The values are not transformed in any way and thus are considered stable
4583    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
4584    pub fn as_str_name(&self) -> &'static str {
4585        match self {
4586            Self::Empty => "Empty",
4587            Self::FromTemplateName => "FromTemplateName",
4588        }
4589    }
4590    /// Creates an enum from field names used in the ProtoBuf definition.
4591    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
4592        match value {
4593            "Empty" => Some(Self::Empty),
4594            "FromTemplateName" => Some(Self::FromTemplateName),
4595            _ => None,
4596        }
4597    }
4598}
4599#[derive(Clone, PartialEq, ::prost::Message)]
4600pub struct ObjectInfo {
4601    #[prost(string, tag = "1")]
4602    pub id: ::prost::alloc::string::String,
4603    /// DEPRECATED
4604    #[prost(string, repeated, tag = "2")]
4605    pub object_type_urls: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4606    #[prost(message, optional, tag = "3")]
4607    pub details: ::core::option::Option<::prost_types::Struct>,
4608    /// DEPRECATED
4609    #[prost(message, repeated, tag = "4")]
4610    pub relations: ::prost::alloc::vec::Vec<Relation>,
4611    #[prost(string, tag = "5")]
4612    pub snippet: ::prost::alloc::string::String,
4613    /// DEPRECATED
4614    #[prost(bool, tag = "6")]
4615    pub has_inbound_links: bool,
4616}
4617#[derive(Clone, PartialEq, ::prost::Message)]
4618pub struct ObjectDetails {
4619    #[prost(message, optional, tag = "1")]
4620    pub details: ::core::option::Option<::prost_types::Struct>,
4621}
4622#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
4623pub struct ObjectLinks {
4624    #[prost(string, repeated, tag = "1")]
4625    pub inbound_i_ds: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4626    #[prost(string, repeated, tag = "2")]
4627    pub outbound_i_ds: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4628}
4629#[derive(Clone, PartialEq, ::prost::Message)]
4630pub struct ObjectLinksInfo {
4631    #[prost(message, repeated, tag = "1")]
4632    pub inbound: ::prost::alloc::vec::Vec<ObjectInfo>,
4633    #[prost(message, repeated, tag = "2")]
4634    pub outbound: ::prost::alloc::vec::Vec<ObjectInfo>,
4635}
4636#[derive(Clone, PartialEq, ::prost::Message)]
4637pub struct ObjectInfoWithLinks {
4638    #[prost(string, tag = "1")]
4639    pub id: ::prost::alloc::string::String,
4640    #[prost(message, optional, tag = "2")]
4641    pub info: ::core::option::Option<ObjectInfo>,
4642    #[prost(message, optional, tag = "3")]
4643    pub links: ::core::option::Option<ObjectLinksInfo>,
4644}
4645#[derive(Clone, PartialEq, ::prost::Message)]
4646pub struct ObjectInfoWithOutboundLinks {
4647    #[prost(string, tag = "1")]
4648    pub id: ::prost::alloc::string::String,
4649    #[prost(message, optional, tag = "2")]
4650    pub info: ::core::option::Option<ObjectInfo>,
4651    #[prost(message, repeated, tag = "3")]
4652    pub outbound_links: ::prost::alloc::vec::Vec<ObjectInfo>,
4653}
4654#[derive(Clone, PartialEq, ::prost::Message)]
4655pub struct ObjectInfoWithOutboundLinksIDs {
4656    #[prost(string, tag = "1")]
4657    pub id: ::prost::alloc::string::String,
4658    #[prost(message, optional, tag = "2")]
4659    pub info: ::core::option::Option<ObjectInfo>,
4660    #[prost(string, repeated, tag = "3")]
4661    pub outbound_links: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
4662}
4663#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
4664pub struct ObjectStoreChecksums {
4665    #[prost(string, tag = "1")]
4666    pub bundled_object_types: ::prost::alloc::string::String,
4667    #[prost(string, tag = "2")]
4668    pub bundled_relations: ::prost::alloc::string::String,
4669    #[prost(string, tag = "3")]
4670    pub bundled_layouts: ::prost::alloc::string::String,
4671    /// increased in order to trigger all objects reindex
4672    #[prost(int32, tag = "4")]
4673    pub objects_force_reindex_counter: i32,
4674    /// increased in order to fully reindex all objects
4675    #[prost(int32, tag = "5")]
4676    pub files_force_reindex_counter: i32,
4677    /// increased in order to remove indexes and reindex everything. Automatically triggers objects and files reindex(one time only)
4678    #[prost(int32, tag = "6")]
4679    pub idx_rebuild_counter: i32,
4680    /// DEPRECATED increased in order to perform fulltext indexing for all type of objects (useful when we change fulltext config)
4681    #[prost(int32, tag = "7")]
4682    pub fulltext_rebuild: i32,
4683    /// DEPRECATED remove all the fulltext indexes and add to reindex queue after
4684    #[prost(int32, tag = "11")]
4685    pub fulltext_erase: i32,
4686    #[prost(string, tag = "8")]
4687    pub bundled_templates: ::prost::alloc::string::String,
4688    /// anytypeProfile and maybe some others in the feature
4689    #[prost(int32, tag = "9")]
4690    pub bundled_objects: i32,
4691    #[prost(int32, tag = "10")]
4692    pub filestore_keys_force_reindex_counter: i32,
4693    #[prost(bool, tag = "12")]
4694    pub are_old_files_removed: bool,
4695    /// DEPRECATED
4696    #[prost(bool, tag = "13")]
4697    pub are_deleted_objects_reindexed: bool,
4698    #[prost(int32, tag = "14")]
4699    pub links_erase: i32,
4700    #[prost(int32, tag = "15")]
4701    pub marketplace_force_reindex_counter: i32,
4702    #[prost(int32, tag = "16")]
4703    pub reindex_deleted_objects: i32,
4704    #[prost(int32, tag = "17")]
4705    pub reindex_participants: i32,
4706    #[prost(int32, tag = "18")]
4707    pub reindex_chats: i32,
4708    #[prost(int32, tag = "19")]
4709    pub reindex_fulltext_chat_messages: i32,
4710    #[prost(int32, tag = "20")]
4711    pub invalidate_objects_index: i32,
4712}
anytype_rpc/gen/anytype.model.rs

anytype_rpc/gen/
anytype.model.rs
