1#[derive(Clone, PartialEq, ::prost::Message)]
3pub struct Namespace {
4 #[prost(string, repeated, tag = "1")]
5 pub levels: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
6}
7#[derive(Clone, PartialEq, ::prost::Message)]
8pub struct TableName {
9 #[prost(string, tag = "1")]
10 pub name: ::prost::alloc::string::String,
11}
12#[derive(Clone, PartialEq, ::prost::Message)]
13pub struct TableTarget {
14 #[prost(message, optional, tag = "1")]
15 pub namespace: ::core::option::Option<Namespace>,
16 #[prost(message, optional, tag = "2")]
17 pub table_name: ::core::option::Option<TableName>,
18}
19#[derive(Clone, PartialEq, ::prost::Message)]
20pub struct IcebergFileWrittenEvent {
21 #[prost(message, optional, tag = "1")]
22 pub table: ::core::option::Option<TableTarget>,
23 #[prost(int32, tag = "2")]
24 pub partition_value: i32,
25 #[prost(string, tag = "3")]
26 pub object_key: ::prost::alloc::string::String,
27 #[prost(message, optional, tag = "4")]
28 pub ingested_at: ::core::option::Option<
29 super::super::super::google::protobuf::Timestamp,
30 >,
31 #[prost(string, tag = "5")]
32 pub source_topic: ::prost::alloc::string::String,
33 #[prost(int32, tag = "6")]
34 pub source_partition: i32,
35 #[prost(int64, tag = "7")]
36 pub source_end_offset: i64,
37 #[prost(message, optional, tag = "8")]
38 pub oldest_source_record_timestamp: ::core::option::Option<
39 super::super::super::google::protobuf::Timestamp,
40 >,
41 #[prost(int64, optional, tag = "9")]
42 pub file_size_bytes: ::core::option::Option<i64>,
43 #[prost(message, optional, tag = "12")]
44 pub file_ingest_batch: ::core::option::Option<FileIngestBatch>,
45 #[prost(oneof = "iceberg_file_written_event::Metrics", tags = "10")]
46 pub metrics: ::core::option::Option<iceberg_file_written_event::Metrics>,
47}
48pub mod iceberg_file_written_event {
50 #[derive(Clone, PartialEq, ::prost::Oneof)]
51 pub enum Metrics {
52 #[prost(message, tag = "10")]
53 MetricsV1(super::IcebergFileMetricsV1),
54 }
55}
56#[derive(Clone, PartialEq, ::prost::Message)]
57pub struct FileIngestBatch {
58 #[prost(string, tag = "1")]
59 pub ingest_job_rid: ::prost::alloc::string::String,
60 #[prost(string, tag = "2")]
61 pub dataset_file_id: ::prost::alloc::string::String,
62 #[prost(int32, tag = "3")]
63 pub batch_id: i32,
64 #[prost(int64, tag = "4")]
65 pub point_count: i64,
66 #[prost(message, optional, tag = "5")]
67 pub min_timestamp: ::core::option::Option<
68 super::super::super::google::protobuf::Timestamp,
69 >,
70 #[prost(message, optional, tag = "6")]
71 pub max_timestamp: ::core::option::Option<
72 super::super::super::google::protobuf::Timestamp,
73 >,
74 #[prost(message, repeated, tag = "7")]
75 pub series: ::prost::alloc::vec::Vec<FileIngestSeries>,
76}
77#[derive(Clone, PartialEq, ::prost::Message)]
78pub struct FileIngestSeries {
79 #[prost(string, tag = "1")]
80 pub channel: ::prost::alloc::string::String,
81 #[prost(enumeration = "FileIngestSeriesType", tag = "2")]
82 pub r#type: i32,
83 #[prost(string, optional, tag = "3")]
84 pub unit: ::core::option::Option<::prost::alloc::string::String>,
85}
86#[derive(Clone, PartialEq, ::prost::Message)]
87pub struct IcebergFileMetricsV1 {
88 #[prost(int32, optional, tag = "1")]
89 pub schema_id: ::core::option::Option<i32>,
90 #[prost(int64, tag = "2")]
91 pub record_count: i64,
92 #[prost(map = "int32, int64", tag = "3")]
93 pub column_sizes: ::std::collections::HashMap<i32, i64>,
94 #[prost(map = "int32, int64", tag = "4")]
95 pub value_counts: ::std::collections::HashMap<i32, i64>,
96 #[prost(map = "int32, int64", tag = "5")]
97 pub null_value_counts: ::std::collections::HashMap<i32, i64>,
98 #[prost(map = "int32, int64", tag = "6")]
99 pub nan_value_counts: ::std::collections::HashMap<i32, i64>,
100 #[prost(map = "int32, bytes", tag = "7")]
101 pub lower_bounds: ::std::collections::HashMap<i32, ::prost::alloc::vec::Vec<u8>>,
102 #[prost(map = "int32, bytes", tag = "8")]
103 pub upper_bounds: ::std::collections::HashMap<i32, ::prost::alloc::vec::Vec<u8>>,
104}
105#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
106#[repr(i32)]
107pub enum FileIngestSeriesType {
108 Unspecified = 0,
109 Double = 1,
110 String = 2,
111 Log = 3,
112 Int64 = 4,
113 Uint64 = 5,
114 DoubleArray = 6,
115 StringArray = 7,
116 Struct = 8,
117 Video = 9,
118 Spatial = 10,
119}
120impl FileIngestSeriesType {
121 pub fn as_str_name(&self) -> &'static str {
126 match self {
127 Self::Unspecified => "FILE_INGEST_SERIES_TYPE_UNSPECIFIED",
128 Self::Double => "FILE_INGEST_SERIES_TYPE_DOUBLE",
129 Self::String => "FILE_INGEST_SERIES_TYPE_STRING",
130 Self::Log => "FILE_INGEST_SERIES_TYPE_LOG",
131 Self::Int64 => "FILE_INGEST_SERIES_TYPE_INT64",
132 Self::Uint64 => "FILE_INGEST_SERIES_TYPE_UINT64",
133 Self::DoubleArray => "FILE_INGEST_SERIES_TYPE_DOUBLE_ARRAY",
134 Self::StringArray => "FILE_INGEST_SERIES_TYPE_STRING_ARRAY",
135 Self::Struct => "FILE_INGEST_SERIES_TYPE_STRUCT",
136 Self::Video => "FILE_INGEST_SERIES_TYPE_VIDEO",
137 Self::Spatial => "FILE_INGEST_SERIES_TYPE_SPATIAL",
138 }
139 }
140 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
142 match value {
143 "FILE_INGEST_SERIES_TYPE_UNSPECIFIED" => Some(Self::Unspecified),
144 "FILE_INGEST_SERIES_TYPE_DOUBLE" => Some(Self::Double),
145 "FILE_INGEST_SERIES_TYPE_STRING" => Some(Self::String),
146 "FILE_INGEST_SERIES_TYPE_LOG" => Some(Self::Log),
147 "FILE_INGEST_SERIES_TYPE_INT64" => Some(Self::Int64),
148 "FILE_INGEST_SERIES_TYPE_UINT64" => Some(Self::Uint64),
149 "FILE_INGEST_SERIES_TYPE_DOUBLE_ARRAY" => Some(Self::DoubleArray),
150 "FILE_INGEST_SERIES_TYPE_STRING_ARRAY" => Some(Self::StringArray),
151 "FILE_INGEST_SERIES_TYPE_STRUCT" => Some(Self::Struct),
152 "FILE_INGEST_SERIES_TYPE_VIDEO" => Some(Self::Video),
153 "FILE_INGEST_SERIES_TYPE_SPATIAL" => Some(Self::Spatial),
154 _ => None,
155 }
156 }
157}
158#[derive(Clone, PartialEq, ::prost::Message)]
159pub struct MaintenanceAction {
160 #[prost(message, optional, tag = "1")]
161 pub target: ::core::option::Option<TableTarget>,
162 #[prost(oneof = "maintenance_action::Action", tags = "2, 3, 4, 5, 6, 7, 8")]
163 pub action: ::core::option::Option<maintenance_action::Action>,
164}
165pub mod maintenance_action {
167 #[derive(Clone, PartialEq, ::prost::Oneof)]
168 pub enum Action {
169 #[prost(message, tag = "2")]
170 RewriteDataFiles(super::RewriteDataFiles),
171 #[prost(message, tag = "3")]
172 RewriteManifests(super::RewriteManifests),
173 #[prost(message, tag = "4")]
174 ExpireSnapshots(super::ExpireSnapshots),
175 #[prost(message, tag = "5")]
176 RemoveOrphanFiles(super::RemoveOrphanFiles),
177 #[prost(message, tag = "6")]
178 RemoveDuplicateDataFiles(super::RemoveDuplicateDataFiles),
179 #[prost(message, tag = "7")]
180 DeleteRows(super::DeleteRows),
181 #[prost(message, tag = "8")]
182 MergeSeriesRows(super::MergeSeriesRows),
183 }
184}
185#[derive(Clone, Copy, PartialEq, ::prost::Message)]
186pub struct RewriteDataFiles {
187 #[prost(uint64, optional, tag = "1")]
188 pub target_file_size_bytes: ::core::option::Option<u64>,
189 #[prost(uint32, optional, tag = "2")]
190 pub partial_progress_max_commits: ::core::option::Option<u32>,
191 #[prost(uint64, optional, tag = "3")]
192 pub max_file_group_size_bytes: ::core::option::Option<u64>,
193 #[prost(uint64, optional, tag = "4")]
194 pub min_file_size_bytes: ::core::option::Option<u64>,
195 #[prost(uint64, optional, tag = "5")]
196 pub max_file_size_bytes: ::core::option::Option<u64>,
197 #[prost(uint32, optional, tag = "6")]
198 pub min_input_files: ::core::option::Option<u32>,
199 #[prost(uint32, optional, tag = "7")]
200 pub max_files_to_rewrite: ::core::option::Option<u32>,
201 #[prost(uint32, optional, tag = "8")]
202 pub max_concurrent_file_group_rewrites: ::core::option::Option<u32>,
203 #[prost(uint32, optional, tag = "9")]
204 pub shuffle_partitions_per_file: ::core::option::Option<u32>,
205 #[prost(double, optional, tag = "10")]
206 pub compression_factor: ::core::option::Option<f64>,
207 #[prost(enumeration = "RewriteJobOrder", tag = "11")]
208 pub rewrite_job_order: i32,
209 #[prost(uint32, optional, tag = "12")]
210 pub partial_progress_max_failed_commits: ::core::option::Option<u32>,
211 #[prost(uint64, optional, tag = "13")]
212 pub min_data_age_millis: ::core::option::Option<u64>,
213 #[prost(enumeration = "RewriteTier", tag = "14")]
214 pub tier: i32,
215}
216#[derive(Clone, Copy, PartialEq, ::prost::Message)]
217pub struct MergeSeriesRows {
218 #[prost(uint64, optional, tag = "1")]
219 pub target_file_size_bytes: ::core::option::Option<u64>,
220}
221#[derive(Clone, Copy, PartialEq, ::prost::Message)]
222pub struct RewriteManifests {}
223#[derive(Clone, Copy, PartialEq, ::prost::Message)]
224pub struct ExpireSnapshots {}
225#[derive(Clone, Copy, PartialEq, ::prost::Message)]
226pub struct RemoveOrphanFiles {
227 #[prost(uint64, optional, tag = "1")]
228 pub min_orphan_file_age_millis: ::core::option::Option<u64>,
229}
230#[derive(Clone, Copy, PartialEq, ::prost::Message)]
231pub struct RemoveDuplicateDataFiles {}
232#[derive(Clone, Copy, PartialEq, ::prost::Message)]
233pub struct DeleteRowsTimeRange {
234 #[prost(uint64, tag = "1")]
235 pub start_inclusive_nanos: u64,
236 #[prost(uint64, tag = "2")]
237 pub end_inclusive_nanos: u64,
238}
239#[derive(Clone, PartialEq, ::prost::Message)]
240pub struct DeleteRows {
241 #[prost(message, repeated, tag = "1")]
242 pub data_table_targets: ::prost::alloc::vec::Vec<TableTarget>,
243 #[prost(message, optional, tag = "2")]
244 pub series_table_target: ::core::option::Option<TableTarget>,
245 #[prost(string, repeated, tag = "3")]
246 pub series_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
247 #[prost(message, optional, tag = "4")]
248 pub time_range: ::core::option::Option<DeleteRowsTimeRange>,
249 #[prost(message, repeated, tag = "5")]
250 pub exemption_ranges: ::prost::alloc::vec::Vec<DeleteRowsTimeRange>,
251 #[prost(bool, tag = "6")]
252 pub dry_run: bool,
253}
254#[derive(Clone, PartialEq, ::prost::Message)]
255pub struct GetMaintenanceRunResponse {
256 #[prost(string, tag = "1")]
257 pub run_id: ::prost::alloc::string::String,
258 #[prost(message, repeated, tag = "2")]
259 pub actions: ::prost::alloc::vec::Vec<MaintenanceAction>,
260 #[prost(enumeration = "MaintenanceRunStatus", tag = "3")]
261 pub status: i32,
262 #[prost(message, optional, tag = "4")]
263 pub started_at: ::core::option::Option<
264 super::super::super::google::protobuf::Timestamp,
265 >,
266 #[prost(message, optional, tag = "5")]
267 pub finished_at: ::core::option::Option<
268 super::super::super::google::protobuf::Timestamp,
269 >,
270}
271#[derive(Clone, PartialEq, ::prost::Message)]
272pub struct RunMaintenanceRequest {
273 #[prost(message, repeated, tag = "1")]
274 pub actions: ::prost::alloc::vec::Vec<MaintenanceAction>,
275 #[prost(string, optional, tag = "2")]
276 pub image_override: ::core::option::Option<::prost::alloc::string::String>,
277 #[prost(bool, tag = "3")]
278 pub enable_spark_ui: bool,
279}
280#[derive(Clone, PartialEq, ::prost::Message)]
281pub struct RunMaintenanceResponse {
282 #[prost(string, tag = "1")]
283 pub run_id: ::prost::alloc::string::String,
284}
285#[derive(Clone, PartialEq, ::prost::Message)]
286pub struct GetMaintenanceRunRequest {
287 #[prost(string, tag = "1")]
288 pub run_id: ::prost::alloc::string::String,
289}
290#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
291#[repr(i32)]
292pub enum RewriteJobOrder {
293 Unspecified = 0,
294 BytesAsc = 1,
295 BytesDesc = 2,
296 FilesAsc = 3,
297 FilesDesc = 4,
298 None = 5,
299}
300impl RewriteJobOrder {
301 pub fn as_str_name(&self) -> &'static str {
306 match self {
307 Self::Unspecified => "REWRITE_JOB_ORDER_UNSPECIFIED",
308 Self::BytesAsc => "REWRITE_JOB_ORDER_BYTES_ASC",
309 Self::BytesDesc => "REWRITE_JOB_ORDER_BYTES_DESC",
310 Self::FilesAsc => "REWRITE_JOB_ORDER_FILES_ASC",
311 Self::FilesDesc => "REWRITE_JOB_ORDER_FILES_DESC",
312 Self::None => "REWRITE_JOB_ORDER_NONE",
313 }
314 }
315 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
317 match value {
318 "REWRITE_JOB_ORDER_UNSPECIFIED" => Some(Self::Unspecified),
319 "REWRITE_JOB_ORDER_BYTES_ASC" => Some(Self::BytesAsc),
320 "REWRITE_JOB_ORDER_BYTES_DESC" => Some(Self::BytesDesc),
321 "REWRITE_JOB_ORDER_FILES_ASC" => Some(Self::FilesAsc),
322 "REWRITE_JOB_ORDER_FILES_DESC" => Some(Self::FilesDesc),
323 "REWRITE_JOB_ORDER_NONE" => Some(Self::None),
324 _ => None,
325 }
326 }
327}
328#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
329#[repr(i32)]
330pub enum RewriteTier {
331 Unspecified = 0,
332 Small = 1,
333 Medium = 2,
334 Large = 3,
335}
336impl RewriteTier {
337 pub fn as_str_name(&self) -> &'static str {
342 match self {
343 Self::Unspecified => "REWRITE_TIER_UNSPECIFIED",
344 Self::Small => "REWRITE_TIER_SMALL",
345 Self::Medium => "REWRITE_TIER_MEDIUM",
346 Self::Large => "REWRITE_TIER_LARGE",
347 }
348 }
349 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
351 match value {
352 "REWRITE_TIER_UNSPECIFIED" => Some(Self::Unspecified),
353 "REWRITE_TIER_SMALL" => Some(Self::Small),
354 "REWRITE_TIER_MEDIUM" => Some(Self::Medium),
355 "REWRITE_TIER_LARGE" => Some(Self::Large),
356 _ => None,
357 }
358 }
359}
360#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
361#[repr(i32)]
362pub enum MaintenanceRunStatus {
363 Unspecified = 0,
364 Pending = 1,
365 Running = 2,
366 Succeeded = 3,
367 Failed = 4,
368}
369impl MaintenanceRunStatus {
370 pub fn as_str_name(&self) -> &'static str {
375 match self {
376 Self::Unspecified => "MAINTENANCE_RUN_STATUS_UNSPECIFIED",
377 Self::Pending => "MAINTENANCE_RUN_STATUS_PENDING",
378 Self::Running => "MAINTENANCE_RUN_STATUS_RUNNING",
379 Self::Succeeded => "MAINTENANCE_RUN_STATUS_SUCCEEDED",
380 Self::Failed => "MAINTENANCE_RUN_STATUS_FAILED",
381 }
382 }
383 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
385 match value {
386 "MAINTENANCE_RUN_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
387 "MAINTENANCE_RUN_STATUS_PENDING" => Some(Self::Pending),
388 "MAINTENANCE_RUN_STATUS_RUNNING" => Some(Self::Running),
389 "MAINTENANCE_RUN_STATUS_SUCCEEDED" => Some(Self::Succeeded),
390 "MAINTENANCE_RUN_STATUS_FAILED" => Some(Self::Failed),
391 _ => None,
392 }
393 }
394}
395#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
396#[repr(i32)]
397pub enum TableMaintenanceErrors {
398 Unspecified = 0,
399 TableNotFound = 1,
400}
401impl TableMaintenanceErrors {
402 pub fn as_str_name(&self) -> &'static str {
407 match self {
408 Self::Unspecified => "TABLE_MAINTENANCE_ERRORS_UNSPECIFIED",
409 Self::TableNotFound => "TABLE_MAINTENANCE_ERRORS_TABLE_NOT_FOUND",
410 }
411 }
412 pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
414 match value {
415 "TABLE_MAINTENANCE_ERRORS_UNSPECIFIED" => Some(Self::Unspecified),
416 "TABLE_MAINTENANCE_ERRORS_TABLE_NOT_FOUND" => Some(Self::TableNotFound),
417 _ => None,
418 }
419 }
420}
421pub mod iceberg_table_maintenance_service_client {
423 #![allow(
424 unused_variables,
425 dead_code,
426 missing_docs,
427 clippy::wildcard_imports,
428 clippy::let_unit_value,
429 )]
430 use tonic::codegen::*;
431 use tonic::codegen::http::Uri;
432 #[derive(Debug, Clone)]
433 pub struct IcebergTableMaintenanceServiceClient<T> {
434 inner: tonic::client::Grpc<T>,
435 }
436 impl IcebergTableMaintenanceServiceClient<tonic::transport::Channel> {
437 pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
439 where
440 D: TryInto<tonic::transport::Endpoint>,
441 D::Error: Into<StdError>,
442 {
443 let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
444 Ok(Self::new(conn))
445 }
446 }
447 impl<T> IcebergTableMaintenanceServiceClient<T>
448 where
449 T: tonic::client::GrpcService<tonic::body::Body>,
450 T::Error: Into<StdError>,
451 T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
452 <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
453 {
454 pub fn new(inner: T) -> Self {
455 let inner = tonic::client::Grpc::new(inner);
456 Self { inner }
457 }
458 pub fn with_origin(inner: T, origin: Uri) -> Self {
459 let inner = tonic::client::Grpc::with_origin(inner, origin);
460 Self { inner }
461 }
462 pub fn with_interceptor<F>(
463 inner: T,
464 interceptor: F,
465 ) -> IcebergTableMaintenanceServiceClient<InterceptedService<T, F>>
466 where
467 F: tonic::service::Interceptor,
468 T::ResponseBody: Default,
469 T: tonic::codegen::Service<
470 http::Request<tonic::body::Body>,
471 Response = http::Response<
472 <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
473 >,
474 >,
475 <T as tonic::codegen::Service<
476 http::Request<tonic::body::Body>,
477 >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
478 {
479 IcebergTableMaintenanceServiceClient::new(
480 InterceptedService::new(inner, interceptor),
481 )
482 }
483 #[must_use]
488 pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
489 self.inner = self.inner.send_compressed(encoding);
490 self
491 }
492 #[must_use]
494 pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
495 self.inner = self.inner.accept_compressed(encoding);
496 self
497 }
498 #[must_use]
502 pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
503 self.inner = self.inner.max_decoding_message_size(limit);
504 self
505 }
506 #[must_use]
510 pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
511 self.inner = self.inner.max_encoding_message_size(limit);
512 self
513 }
514 pub async fn run_maintenance(
515 &mut self,
516 request: impl tonic::IntoRequest<super::RunMaintenanceRequest>,
517 ) -> std::result::Result<
518 tonic::Response<super::RunMaintenanceResponse>,
519 tonic::Status,
520 > {
521 self.inner
522 .ready()
523 .await
524 .map_err(|e| {
525 tonic::Status::unknown(
526 format!("Service was not ready: {}", e.into()),
527 )
528 })?;
529 let codec = tonic::codec::ProstCodec::default();
530 let path = http::uri::PathAndQuery::from_static(
531 "/nominal.iceberg.v1.IcebergTableMaintenanceService/RunMaintenance",
532 );
533 let mut req = request.into_request();
534 req.extensions_mut()
535 .insert(
536 GrpcMethod::new(
537 "nominal.iceberg.v1.IcebergTableMaintenanceService",
538 "RunMaintenance",
539 ),
540 );
541 self.inner.unary(req, path, codec).await
542 }
543 pub async fn get_maintenance_run(
544 &mut self,
545 request: impl tonic::IntoRequest<super::GetMaintenanceRunRequest>,
546 ) -> std::result::Result<
547 tonic::Response<super::GetMaintenanceRunResponse>,
548 tonic::Status,
549 > {
550 self.inner
551 .ready()
552 .await
553 .map_err(|e| {
554 tonic::Status::unknown(
555 format!("Service was not ready: {}", e.into()),
556 )
557 })?;
558 let codec = tonic::codec::ProstCodec::default();
559 let path = http::uri::PathAndQuery::from_static(
560 "/nominal.iceberg.v1.IcebergTableMaintenanceService/GetMaintenanceRun",
561 );
562 let mut req = request.into_request();
563 req.extensions_mut()
564 .insert(
565 GrpcMethod::new(
566 "nominal.iceberg.v1.IcebergTableMaintenanceService",
567 "GetMaintenanceRun",
568 ),
569 );
570 self.inner.unary(req, path, codec).await
571 }
572 }
573}