ydb_grpc_bindings/generated/
ydb.export.rs

1/// / Common
2#[allow(clippy::derive_partial_eq_without_eq)]
3#[derive(Clone, PartialEq, ::prost::Message)]
4pub struct ExportProgress {}
5/// Nested message and enum types in `ExportProgress`.
6pub mod export_progress {
7    #[derive(
8        Clone,
9        Copy,
10        Debug,
11        PartialEq,
12        Eq,
13        Hash,
14        PartialOrd,
15        Ord,
16        ::prost::Enumeration
17    )]
18    #[repr(i32)]
19    pub enum Progress {
20        Unspecified = 0,
21        Preparing = 1,
22        TransferData = 2,
23        Done = 3,
24        Cancellation = 4,
25        Cancelled = 5,
26    }
27    impl Progress {
28        /// String value of the enum field names used in the ProtoBuf definition.
29        ///
30        /// The values are not transformed in any way and thus are considered stable
31        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
32        pub fn as_str_name(&self) -> &'static str {
33            match self {
34                Progress::Unspecified => "PROGRESS_UNSPECIFIED",
35                Progress::Preparing => "PROGRESS_PREPARING",
36                Progress::TransferData => "PROGRESS_TRANSFER_DATA",
37                Progress::Done => "PROGRESS_DONE",
38                Progress::Cancellation => "PROGRESS_CANCELLATION",
39                Progress::Cancelled => "PROGRESS_CANCELLED",
40            }
41        }
42        /// Creates an enum from field names used in the ProtoBuf definition.
43        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
44            match value {
45                "PROGRESS_UNSPECIFIED" => Some(Self::Unspecified),
46                "PROGRESS_PREPARING" => Some(Self::Preparing),
47                "PROGRESS_TRANSFER_DATA" => Some(Self::TransferData),
48                "PROGRESS_DONE" => Some(Self::Done),
49                "PROGRESS_CANCELLATION" => Some(Self::Cancellation),
50                "PROGRESS_CANCELLED" => Some(Self::Cancelled),
51                _ => None,
52            }
53        }
54    }
55}
56#[allow(clippy::derive_partial_eq_without_eq)]
57#[derive(Clone, PartialEq, ::prost::Message)]
58pub struct ExportItemProgress {
59    #[prost(uint32, tag = "1")]
60    pub parts_total: u32,
61    #[prost(uint32, tag = "2")]
62    pub parts_completed: u32,
63    #[prost(message, optional, tag = "3")]
64    pub start_time: ::core::option::Option<super::super::google::protobuf::Timestamp>,
65    #[prost(message, optional, tag = "4")]
66    pub end_time: ::core::option::Option<super::super::google::protobuf::Timestamp>,
67}
68/// / YT
69#[allow(clippy::derive_partial_eq_without_eq)]
70#[derive(Clone, PartialEq, ::prost::Message)]
71pub struct ExportToYtSettings {
72    #[prost(string, tag = "1")]
73    pub host: ::prost::alloc::string::String,
74    #[prost(uint32, tag = "2")]
75    pub port: u32,
76    #[prost(string, tag = "3")]
77    pub token: ::prost::alloc::string::String,
78    #[prost(message, repeated, tag = "4")]
79    pub items: ::prost::alloc::vec::Vec<export_to_yt_settings::Item>,
80    #[prost(string, tag = "5")]
81    pub description: ::prost::alloc::string::String,
82    #[prost(uint32, tag = "6")]
83    pub number_of_retries: u32,
84    #[prost(bool, tag = "7")]
85    pub use_type_v3: bool,
86}
87/// Nested message and enum types in `ExportToYtSettings`.
88pub mod export_to_yt_settings {
89    #[allow(clippy::derive_partial_eq_without_eq)]
90    #[derive(Clone, PartialEq, ::prost::Message)]
91    pub struct Item {
92        /// Database path to a table to be exported
93        #[prost(string, tag = "1")]
94        pub source_path: ::prost::alloc::string::String,
95        #[prost(string, tag = "2")]
96        pub destination_path: ::prost::alloc::string::String,
97    }
98}
99#[allow(clippy::derive_partial_eq_without_eq)]
100#[derive(Clone, PartialEq, ::prost::Message)]
101pub struct ExportToYtResult {}
102#[allow(clippy::derive_partial_eq_without_eq)]
103#[derive(Clone, PartialEq, ::prost::Message)]
104pub struct ExportToYtMetadata {
105    #[prost(message, optional, tag = "1")]
106    pub settings: ::core::option::Option<ExportToYtSettings>,
107    #[prost(enumeration = "export_progress::Progress", tag = "2")]
108    pub progress: i32,
109    #[prost(message, repeated, tag = "3")]
110    pub items_progress: ::prost::alloc::vec::Vec<ExportItemProgress>,
111}
112#[allow(clippy::derive_partial_eq_without_eq)]
113#[derive(Clone, PartialEq, ::prost::Message)]
114pub struct ExportToYtRequest {
115    #[prost(message, optional, tag = "1")]
116    pub operation_params: ::core::option::Option<super::operations::OperationParams>,
117    #[prost(message, optional, tag = "2")]
118    pub settings: ::core::option::Option<ExportToYtSettings>,
119}
120#[allow(clippy::derive_partial_eq_without_eq)]
121#[derive(Clone, PartialEq, ::prost::Message)]
122pub struct ExportToYtResponse {
123    /// operation.result = ExportToYtResult
124    /// operation.metadata = ExportToYtMetadata
125    #[prost(message, optional, tag = "1")]
126    pub operation: ::core::option::Option<super::operations::Operation>,
127}
128/// / S3
129#[allow(clippy::derive_partial_eq_without_eq)]
130#[derive(Clone, PartialEq, ::prost::Message)]
131pub struct ExportToS3Settings {
132    #[prost(string, tag = "1")]
133    pub endpoint: ::prost::alloc::string::String,
134    /// HTTPS if not specified
135    #[prost(enumeration = "export_to_s3_settings::Scheme", tag = "2")]
136    pub scheme: i32,
137    #[prost(string, tag = "3")]
138    pub bucket: ::prost::alloc::string::String,
139    #[prost(string, tag = "4")]
140    pub access_key: ::prost::alloc::string::String,
141    #[prost(string, tag = "5")]
142    pub secret_key: ::prost::alloc::string::String,
143    #[prost(message, repeated, tag = "6")]
144    pub items: ::prost::alloc::vec::Vec<export_to_s3_settings::Item>,
145    #[prost(string, tag = "7")]
146    pub description: ::prost::alloc::string::String,
147    #[prost(uint32, tag = "8")]
148    pub number_of_retries: u32,
149    #[prost(enumeration = "export_to_s3_settings::StorageClass", tag = "9")]
150    pub storage_class: i32,
151    /// Codec used to compress data. Codecs are available:
152    /// - zstd.
153    /// - zstd-N, where N is compression level, e.g. zstd-3.
154    #[prost(string, tag = "10")]
155    pub compression: ::prost::alloc::string::String,
156    /// Region to use in requests
157    #[prost(string, tag = "11")]
158    pub region: ::prost::alloc::string::String,
159}
160/// Nested message and enum types in `ExportToS3Settings`.
161pub mod export_to_s3_settings {
162    #[allow(clippy::derive_partial_eq_without_eq)]
163    #[derive(Clone, PartialEq, ::prost::Message)]
164    pub struct Item {
165        /// Database path to a table to be exported
166        #[prost(string, tag = "1")]
167        pub source_path: ::prost::alloc::string::String,
168        /// Tables are exported to one or more S3 objects.
169        /// The object name begins with 'destination_prefix'.
170        /// This prefix will be followed by '/data_PartNumber', where 'PartNumber'
171        /// represents the index of the part, starting at zero.
172        #[prost(string, tag = "2")]
173        pub destination_prefix: ::prost::alloc::string::String,
174    }
175    #[derive(
176        Clone,
177        Copy,
178        Debug,
179        PartialEq,
180        Eq,
181        Hash,
182        PartialOrd,
183        Ord,
184        ::prost::Enumeration
185    )]
186    #[repr(i32)]
187    pub enum Scheme {
188        Unspecified = 0,
189        Http = 1,
190        Https = 2,
191    }
192    impl Scheme {
193        /// String value of the enum field names used in the ProtoBuf definition.
194        ///
195        /// The values are not transformed in any way and thus are considered stable
196        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
197        pub fn as_str_name(&self) -> &'static str {
198            match self {
199                Scheme::Unspecified => "UNSPECIFIED",
200                Scheme::Http => "HTTP",
201                Scheme::Https => "HTTPS",
202            }
203        }
204        /// Creates an enum from field names used in the ProtoBuf definition.
205        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
206            match value {
207                "UNSPECIFIED" => Some(Self::Unspecified),
208                "HTTP" => Some(Self::Http),
209                "HTTPS" => Some(Self::Https),
210                _ => None,
211            }
212        }
213    }
214    #[derive(
215        Clone,
216        Copy,
217        Debug,
218        PartialEq,
219        Eq,
220        Hash,
221        PartialOrd,
222        Ord,
223        ::prost::Enumeration
224    )]
225    #[repr(i32)]
226    pub enum StorageClass {
227        Unspecified = 0,
228        Standard = 1,
229        ReducedRedundancy = 2,
230        StandardIa = 3,
231        OnezoneIa = 4,
232        IntelligentTiering = 5,
233        Glacier = 6,
234        DeepArchive = 7,
235        Outposts = 8,
236    }
237    impl StorageClass {
238        /// String value of the enum field names used in the ProtoBuf definition.
239        ///
240        /// The values are not transformed in any way and thus are considered stable
241        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
242        pub fn as_str_name(&self) -> &'static str {
243            match self {
244                StorageClass::Unspecified => "STORAGE_CLASS_UNSPECIFIED",
245                StorageClass::Standard => "STANDARD",
246                StorageClass::ReducedRedundancy => "REDUCED_REDUNDANCY",
247                StorageClass::StandardIa => "STANDARD_IA",
248                StorageClass::OnezoneIa => "ONEZONE_IA",
249                StorageClass::IntelligentTiering => "INTELLIGENT_TIERING",
250                StorageClass::Glacier => "GLACIER",
251                StorageClass::DeepArchive => "DEEP_ARCHIVE",
252                StorageClass::Outposts => "OUTPOSTS",
253            }
254        }
255        /// Creates an enum from field names used in the ProtoBuf definition.
256        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
257            match value {
258                "STORAGE_CLASS_UNSPECIFIED" => Some(Self::Unspecified),
259                "STANDARD" => Some(Self::Standard),
260                "REDUCED_REDUNDANCY" => Some(Self::ReducedRedundancy),
261                "STANDARD_IA" => Some(Self::StandardIa),
262                "ONEZONE_IA" => Some(Self::OnezoneIa),
263                "INTELLIGENT_TIERING" => Some(Self::IntelligentTiering),
264                "GLACIER" => Some(Self::Glacier),
265                "DEEP_ARCHIVE" => Some(Self::DeepArchive),
266                "OUTPOSTS" => Some(Self::Outposts),
267                _ => None,
268            }
269        }
270    }
271}
272#[allow(clippy::derive_partial_eq_without_eq)]
273#[derive(Clone, PartialEq, ::prost::Message)]
274pub struct ExportToS3Result {}
275#[allow(clippy::derive_partial_eq_without_eq)]
276#[derive(Clone, PartialEq, ::prost::Message)]
277pub struct ExportToS3Metadata {
278    #[prost(message, optional, tag = "1")]
279    pub settings: ::core::option::Option<ExportToS3Settings>,
280    #[prost(enumeration = "export_progress::Progress", tag = "2")]
281    pub progress: i32,
282    #[prost(message, repeated, tag = "3")]
283    pub items_progress: ::prost::alloc::vec::Vec<ExportItemProgress>,
284}
285#[allow(clippy::derive_partial_eq_without_eq)]
286#[derive(Clone, PartialEq, ::prost::Message)]
287pub struct ExportToS3Request {
288    #[prost(message, optional, tag = "1")]
289    pub operation_params: ::core::option::Option<super::operations::OperationParams>,
290    #[prost(message, optional, tag = "2")]
291    pub settings: ::core::option::Option<ExportToS3Settings>,
292}
293#[allow(clippy::derive_partial_eq_without_eq)]
294#[derive(Clone, PartialEq, ::prost::Message)]
295pub struct ExportToS3Response {
296    /// operation.result = ExportToS3Result
297    /// operation.metadata = ExportToS3Metadata
298    #[prost(message, optional, tag = "1")]
299    pub operation: ::core::option::Option<super::operations::Operation>,
300}