eks_blueprints_rust_sdk/
codegen.rs

1#[allow(clippy::derive_partial_eq_without_eq)]
2#[derive(Clone, PartialEq, ::prost::Message)]
3pub struct AddTeamsRequest {
4    #[prost(string, tag = "1")]
5    pub cluster_name: ::prost::alloc::string::String,
6    #[prost(message, repeated, tag = "2")]
7    pub teams: ::prost::alloc::vec::Vec<Team>,
8}
9#[allow(clippy::derive_partial_eq_without_eq)]
10#[derive(Clone, PartialEq, ::prost::Message)]
11pub struct Team {
12    #[prost(oneof = "team::Team", tags = "1, 2, 3")]
13    pub team: ::core::option::Option<team::Team>,
14}
15/// Nested message and enum types in `Team`.
16pub mod team {
17    #[allow(clippy::derive_partial_eq_without_eq)]
18    #[derive(Clone, PartialEq, ::prost::Oneof)]
19    pub enum Team {
20        #[prost(message, tag = "1")]
21        GenericTeam(super::GenericTeam),
22        #[prost(message, tag = "2")]
23        PlatformTeam(super::PlatformTeam),
24        #[prost(message, tag = "3")]
25        ApplicationTeam(super::ApplicationTeam),
26    }
27}
28#[allow(clippy::derive_partial_eq_without_eq)]
29#[derive(Clone, PartialEq, ::prost::Message)]
30pub struct GenericTeam {
31    #[prost(string, tag = "1")]
32    pub name: ::prost::alloc::string::String,
33}
34#[allow(clippy::derive_partial_eq_without_eq)]
35#[derive(Clone, PartialEq, ::prost::Message)]
36pub struct AddPlatformTeamRequest {
37    #[prost(string, tag = "1")]
38    pub cluster_name: ::prost::alloc::string::String,
39    #[prost(message, optional, tag = "2")]
40    pub props: ::core::option::Option<TeamProps>,
41}
42#[allow(clippy::derive_partial_eq_without_eq)]
43#[derive(Clone, PartialEq, ::prost::Message)]
44pub struct PlatformTeam {
45    #[prost(string, tag = "1")]
46    pub name: ::prost::alloc::string::String,
47}
48#[allow(clippy::derive_partial_eq_without_eq)]
49#[derive(Clone, PartialEq, ::prost::Message)]
50pub struct ApplicationTeam {
51    #[prost(string, tag = "1")]
52    pub name: ::prost::alloc::string::String,
53}
54#[allow(clippy::derive_partial_eq_without_eq)]
55#[derive(Clone, PartialEq, ::prost::Message)]
56pub struct AddApplicationTeamRequest {
57    #[prost(string, tag = "1")]
58    pub cluster_name: ::prost::alloc::string::String,
59    #[prost(message, optional, tag = "2")]
60    pub props: ::core::option::Option<TeamProps>,
61}
62#[allow(clippy::derive_partial_eq_without_eq)]
63#[derive(Clone, PartialEq, ::prost::Message)]
64pub struct TeamProps {
65    #[prost(string, tag = "1")]
66    pub name: ::prost::alloc::string::String,
67}
68#[allow(clippy::derive_partial_eq_without_eq)]
69#[derive(Clone, PartialEq, ::prost::Message)]
70pub struct AddClusterProviderRequest {
71    #[prost(string, tag = "1")]
72    pub cluster_name: ::prost::alloc::string::String,
73    #[prost(message, optional, tag = "2")]
74    pub cluster_provider: ::core::option::Option<ClusterProvider>,
75}
76#[allow(clippy::derive_partial_eq_without_eq)]
77#[derive(Clone, PartialEq, ::prost::Message)]
78pub struct ClusterProvider {
79    #[prost(oneof = "cluster_provider::ClusterProvider", tags = "1, 2")]
80    pub cluster_provider: ::core::option::Option<cluster_provider::ClusterProvider>,
81}
82/// Nested message and enum types in `ClusterProvider`.
83pub mod cluster_provider {
84    #[allow(clippy::derive_partial_eq_without_eq)]
85    #[derive(Clone, PartialEq, ::prost::Oneof)]
86    pub enum ClusterProvider {
87        #[prost(message, tag = "1")]
88        AsgClusterProvider(super::AsgClusterProvider),
89        #[prost(message, tag = "2")]
90        MngClusterProvider(super::MngClusterProvider),
91    }
92}
93#[allow(clippy::derive_partial_eq_without_eq)]
94#[derive(Clone, PartialEq, ::prost::Message)]
95pub struct AddAsgClusterProviderRequest {
96    #[prost(string, tag = "1")]
97    pub cluster_name: ::prost::alloc::string::String,
98    #[prost(message, optional, tag = "2")]
99    pub asg_cluster_provider: ::core::option::Option<AsgClusterProvider>,
100}
101#[allow(clippy::derive_partial_eq_without_eq)]
102#[derive(Clone, PartialEq, ::prost::Message)]
103pub struct AsgClusterProvider {
104    #[prost(string, optional, tag = "1")]
105    pub name: ::core::option::Option<::prost::alloc::string::String>,
106    #[prost(string, tag = "2")]
107    pub version: ::prost::alloc::string::String,
108    #[prost(string, tag = "3")]
109    pub id: ::prost::alloc::string::String,
110}
111#[allow(clippy::derive_partial_eq_without_eq)]
112#[derive(Clone, PartialEq, ::prost::Message)]
113pub struct AddMngClusterProviderRequest {
114    #[prost(string, tag = "1")]
115    pub cluster_name: ::prost::alloc::string::String,
116    #[prost(message, optional, tag = "2")]
117    pub mng_cluster_provider: ::core::option::Option<MngClusterProvider>,
118}
119#[allow(clippy::derive_partial_eq_without_eq)]
120#[derive(Clone, PartialEq, ::prost::Message)]
121pub struct MngClusterProvider {
122    #[prost(string, optional, tag = "1")]
123    pub name: ::core::option::Option<::prost::alloc::string::String>,
124    #[prost(string, tag = "2")]
125    pub version: ::prost::alloc::string::String,
126}
127#[allow(clippy::derive_partial_eq_without_eq)]
128#[derive(Clone, PartialEq, ::prost::Message)]
129pub struct AddResourceProviderRequest {
130    #[prost(string, tag = "1")]
131    pub cluster_name: ::prost::alloc::string::String,
132    #[prost(string, tag = "2")]
133    pub name: ::prost::alloc::string::String,
134    #[prost(message, optional, tag = "3")]
135    pub resource_provider: ::core::option::Option<ResourceProvider>,
136}
137#[allow(clippy::derive_partial_eq_without_eq)]
138#[derive(Clone, PartialEq, ::prost::Message)]
139pub struct ResourceProvider {
140    #[prost(oneof = "resource_provider::ResourceProvider", tags = "1")]
141    pub resource_provider: ::core::option::Option<resource_provider::ResourceProvider>,
142}
143/// Nested message and enum types in `ResourceProvider`.
144pub mod resource_provider {
145    #[allow(clippy::derive_partial_eq_without_eq)]
146    #[derive(Clone, PartialEq, ::prost::Oneof)]
147    pub enum ResourceProvider {
148        #[prost(message, tag = "1")]
149        VpcProvider(super::VpcProvider),
150    }
151}
152#[allow(clippy::derive_partial_eq_without_eq)]
153#[derive(Clone, PartialEq, ::prost::Message)]
154pub struct AddVpcProviderRequest {
155    #[prost(string, tag = "1")]
156    pub cluster_name: ::prost::alloc::string::String,
157    #[prost(string, tag = "2")]
158    pub name: ::prost::alloc::string::String,
159    #[prost(message, optional, tag = "3")]
160    pub vpc_provider: ::core::option::Option<VpcProvider>,
161}
162#[allow(clippy::derive_partial_eq_without_eq)]
163#[derive(Clone, PartialEq, ::prost::Message)]
164pub struct VpcProvider {
165    #[prost(string, optional, tag = "1")]
166    pub vpc_id: ::core::option::Option<::prost::alloc::string::String>,
167}
168#[allow(clippy::derive_partial_eq_without_eq)]
169#[derive(Clone, PartialEq, ::prost::Message)]
170pub struct AddAddonsRequest {
171    #[prost(string, tag = "1")]
172    pub cluster_name: ::prost::alloc::string::String,
173    #[prost(message, repeated, tag = "2")]
174    pub addons: ::prost::alloc::vec::Vec<Addon>,
175}
176#[allow(clippy::derive_partial_eq_without_eq)]
177#[derive(Clone, PartialEq, ::prost::Message)]
178pub struct Addon {
179    #[prost(oneof = "addon::Addon", tags = "1, 2")]
180    pub addon: ::core::option::Option<addon::Addon>,
181}
182/// Nested message and enum types in `Addon`.
183pub mod addon {
184    #[allow(clippy::derive_partial_eq_without_eq)]
185    #[derive(Clone, PartialEq, ::prost::Oneof)]
186    pub enum Addon {
187        #[prost(message, tag = "1")]
188        AckAddOn(super::AckAddOn),
189        #[prost(message, tag = "2")]
190        KubeProxyAddOn(super::KubeProxyAddOn),
191    }
192}
193#[allow(clippy::derive_partial_eq_without_eq)]
194#[derive(Clone, PartialEq, ::prost::Message)]
195pub struct AddAckAddOnRequest {
196    #[prost(string, tag = "1")]
197    pub cluster_name: ::prost::alloc::string::String,
198    #[prost(message, optional, tag = "2")]
199    pub ack_add_on: ::core::option::Option<AckAddOn>,
200}
201#[allow(clippy::derive_partial_eq_without_eq)]
202#[derive(Clone, PartialEq, ::prost::Message)]
203pub struct AckAddOn {
204    #[prost(string, optional, tag = "1")]
205    pub id: ::core::option::Option<::prost::alloc::string::String>,
206    #[prost(string, tag = "2")]
207    pub service_name: ::prost::alloc::string::String,
208}
209#[allow(clippy::derive_partial_eq_without_eq)]
210#[derive(Clone, PartialEq, ::prost::Message)]
211pub struct AddKubeProxyAddOnRequest {
212    #[prost(string, tag = "1")]
213    pub cluster_name: ::prost::alloc::string::String,
214    #[prost(message, optional, tag = "2")]
215    pub kube_proxy_add_on: ::core::option::Option<KubeProxyAddOn>,
216}
217#[allow(clippy::derive_partial_eq_without_eq)]
218#[derive(Clone, PartialEq, ::prost::Message)]
219pub struct KubeProxyAddOn {
220    #[prost(string, optional, tag = "1")]
221    pub version: ::core::option::Option<::prost::alloc::string::String>,
222}
223#[allow(clippy::derive_partial_eq_without_eq)]
224#[derive(Clone, PartialEq, ::prost::Message)]
225pub struct AddCoreDnsAddOnRequest {
226    #[prost(string, tag = "1")]
227    pub cluster_name: ::prost::alloc::string::String,
228    #[prost(message, optional, tag = "2")]
229    pub core_dns_add_on: ::core::option::Option<CoreDnsAddOn>,
230}
231#[allow(clippy::derive_partial_eq_without_eq)]
232#[derive(Clone, PartialEq, ::prost::Message)]
233pub struct CoreDnsAddOn {
234    #[prost(string, optional, tag = "1")]
235    pub version: ::core::option::Option<::prost::alloc::string::String>,
236}
237#[allow(clippy::derive_partial_eq_without_eq)]
238#[derive(Clone, PartialEq, ::prost::Message)]
239pub struct MetricsServerAddOn {
240    #[prost(bool, optional, tag = "1")]
241    pub create_namespace: ::core::option::Option<bool>,
242}
243#[allow(clippy::derive_partial_eq_without_eq)]
244#[derive(Clone, PartialEq, ::prost::Message)]
245pub struct AddMetricsServerAddOnRequest {
246    #[prost(string, tag = "1")]
247    pub cluster_name: ::prost::alloc::string::String,
248    #[prost(message, optional, tag = "2")]
249    pub metrics_server_add_on: ::core::option::Option<MetricsServerAddOn>,
250}
251#[allow(clippy::derive_partial_eq_without_eq)]
252#[derive(Clone, PartialEq, ::prost::Message)]
253pub struct ApiResponse {
254    #[prost(string, tag = "1")]
255    pub message: ::prost::alloc::string::String,
256}
257#[allow(clippy::derive_partial_eq_without_eq)]
258#[derive(Clone, PartialEq, ::prost::Message)]
259pub struct CreateClusterRequest {
260    #[prost(string, tag = "1")]
261    pub id: ::prost::alloc::string::String,
262    #[prost(string, optional, tag = "2")]
263    pub name: ::core::option::Option<::prost::alloc::string::String>,
264}
265#[allow(clippy::derive_partial_eq_without_eq)]
266#[derive(Clone, PartialEq, ::prost::Message)]
267pub struct BuildClusterRequest {
268    #[prost(string, tag = "1")]
269    pub cluster_name: ::prost::alloc::string::String,
270    #[prost(string, optional, tag = "2")]
271    pub account: ::core::option::Option<::prost::alloc::string::String>,
272    #[prost(string, optional, tag = "3")]
273    pub region: ::core::option::Option<::prost::alloc::string::String>,
274}
275#[allow(clippy::derive_partial_eq_without_eq)]
276#[derive(Clone, PartialEq, ::prost::Message)]
277pub struct CloneClusterRequest {
278    #[prost(string, tag = "1")]
279    pub cluster_name: ::prost::alloc::string::String,
280    #[prost(string, tag = "2")]
281    pub new_cluster_id: ::prost::alloc::string::String,
282    #[prost(string, optional, tag = "3")]
283    pub new_cluster_name: ::core::option::Option<::prost::alloc::string::String>,
284    #[prost(string, optional, tag = "4")]
285    pub region: ::core::option::Option<::prost::alloc::string::String>,
286    #[prost(string, optional, tag = "5")]
287    pub account: ::core::option::Option<::prost::alloc::string::String>,
288}
289/// Generated client implementations.
290pub mod cluster_service_client {
291    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
292    use tonic::codegen::*;
293    use tonic::codegen::http::Uri;
294    #[derive(Debug, Clone)]
295    pub struct ClusterServiceClient<T> {
296        inner: tonic::client::Grpc<T>,
297    }
298    impl ClusterServiceClient<tonic::transport::Channel> {
299        /// Attempt to create a new client by connecting to a given endpoint.
300        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
301        where
302            D: TryInto<tonic::transport::Endpoint>,
303            D::Error: Into<StdError>,
304        {
305            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
306            Ok(Self::new(conn))
307        }
308    }
309    impl<T> ClusterServiceClient<T>
310    where
311        T: tonic::client::GrpcService<tonic::body::BoxBody>,
312        T::Error: Into<StdError>,
313        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
314        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
315    {
316        pub fn new(inner: T) -> Self {
317            let inner = tonic::client::Grpc::new(inner);
318            Self { inner }
319        }
320        pub fn with_origin(inner: T, origin: Uri) -> Self {
321            let inner = tonic::client::Grpc::with_origin(inner, origin);
322            Self { inner }
323        }
324        pub fn with_interceptor<F>(
325            inner: T,
326            interceptor: F,
327        ) -> ClusterServiceClient<InterceptedService<T, F>>
328        where
329            F: tonic::service::Interceptor,
330            T::ResponseBody: Default,
331            T: tonic::codegen::Service<
332                http::Request<tonic::body::BoxBody>,
333                Response = http::Response<
334                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
335                >,
336            >,
337            <T as tonic::codegen::Service<
338                http::Request<tonic::body::BoxBody>,
339            >>::Error: Into<StdError> + Send + Sync,
340        {
341            ClusterServiceClient::new(InterceptedService::new(inner, interceptor))
342        }
343        /// Compress requests with the given encoding.
344        ///
345        /// This requires the server to support it otherwise it might respond with an
346        /// error.
347        #[must_use]
348        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
349            self.inner = self.inner.send_compressed(encoding);
350            self
351        }
352        /// Enable decompressing responses.
353        #[must_use]
354        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
355            self.inner = self.inner.accept_compressed(encoding);
356            self
357        }
358        /// Limits the maximum size of a decoded message.
359        ///
360        /// Default: `4MB`
361        #[must_use]
362        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
363            self.inner = self.inner.max_decoding_message_size(limit);
364            self
365        }
366        /// Limits the maximum size of an encoded message.
367        ///
368        /// Default: `usize::MAX`
369        #[must_use]
370        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
371            self.inner = self.inner.max_encoding_message_size(limit);
372            self
373        }
374        pub async fn create_cluster(
375            &mut self,
376            request: impl tonic::IntoRequest<super::CreateClusterRequest>,
377        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
378            self.inner
379                .ready()
380                .await
381                .map_err(|e| {
382                    tonic::Status::new(
383                        tonic::Code::Unknown,
384                        format!("Service was not ready: {}", e.into()),
385                    )
386                })?;
387            let codec = tonic::codec::ProstCodec::default();
388            let path = http::uri::PathAndQuery::from_static(
389                "/codegen.ClusterService/CreateCluster",
390            );
391            let mut req = request.into_request();
392            req.extensions_mut()
393                .insert(GrpcMethod::new("codegen.ClusterService", "CreateCluster"));
394            self.inner.unary(req, path, codec).await
395        }
396        pub async fn build_cluster(
397            &mut self,
398            request: impl tonic::IntoRequest<super::BuildClusterRequest>,
399        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
400            self.inner
401                .ready()
402                .await
403                .map_err(|e| {
404                    tonic::Status::new(
405                        tonic::Code::Unknown,
406                        format!("Service was not ready: {}", e.into()),
407                    )
408                })?;
409            let codec = tonic::codec::ProstCodec::default();
410            let path = http::uri::PathAndQuery::from_static(
411                "/codegen.ClusterService/BuildCluster",
412            );
413            let mut req = request.into_request();
414            req.extensions_mut()
415                .insert(GrpcMethod::new("codegen.ClusterService", "BuildCluster"));
416            self.inner.unary(req, path, codec).await
417        }
418        pub async fn clone_cluster(
419            &mut self,
420            request: impl tonic::IntoRequest<super::CloneClusterRequest>,
421        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
422            self.inner
423                .ready()
424                .await
425                .map_err(|e| {
426                    tonic::Status::new(
427                        tonic::Code::Unknown,
428                        format!("Service was not ready: {}", e.into()),
429                    )
430                })?;
431            let codec = tonic::codec::ProstCodec::default();
432            let path = http::uri::PathAndQuery::from_static(
433                "/codegen.ClusterService/CloneCluster",
434            );
435            let mut req = request.into_request();
436            req.extensions_mut()
437                .insert(GrpcMethod::new("codegen.ClusterService", "CloneCluster"));
438            self.inner.unary(req, path, codec).await
439        }
440        pub async fn add_platform_team(
441            &mut self,
442            request: impl tonic::IntoRequest<super::AddPlatformTeamRequest>,
443        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
444            self.inner
445                .ready()
446                .await
447                .map_err(|e| {
448                    tonic::Status::new(
449                        tonic::Code::Unknown,
450                        format!("Service was not ready: {}", e.into()),
451                    )
452                })?;
453            let codec = tonic::codec::ProstCodec::default();
454            let path = http::uri::PathAndQuery::from_static(
455                "/codegen.ClusterService/AddPlatformTeam",
456            );
457            let mut req = request.into_request();
458            req.extensions_mut()
459                .insert(GrpcMethod::new("codegen.ClusterService", "AddPlatformTeam"));
460            self.inner.unary(req, path, codec).await
461        }
462        pub async fn add_application_team(
463            &mut self,
464            request: impl tonic::IntoRequest<super::AddApplicationTeamRequest>,
465        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
466            self.inner
467                .ready()
468                .await
469                .map_err(|e| {
470                    tonic::Status::new(
471                        tonic::Code::Unknown,
472                        format!("Service was not ready: {}", e.into()),
473                    )
474                })?;
475            let codec = tonic::codec::ProstCodec::default();
476            let path = http::uri::PathAndQuery::from_static(
477                "/codegen.ClusterService/AddApplicationTeam",
478            );
479            let mut req = request.into_request();
480            req.extensions_mut()
481                .insert(GrpcMethod::new("codegen.ClusterService", "AddApplicationTeam"));
482            self.inner.unary(req, path, codec).await
483        }
484        pub async fn add_teams(
485            &mut self,
486            request: impl tonic::IntoRequest<super::AddTeamsRequest>,
487        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
488            self.inner
489                .ready()
490                .await
491                .map_err(|e| {
492                    tonic::Status::new(
493                        tonic::Code::Unknown,
494                        format!("Service was not ready: {}", e.into()),
495                    )
496                })?;
497            let codec = tonic::codec::ProstCodec::default();
498            let path = http::uri::PathAndQuery::from_static(
499                "/codegen.ClusterService/AddTeams",
500            );
501            let mut req = request.into_request();
502            req.extensions_mut()
503                .insert(GrpcMethod::new("codegen.ClusterService", "AddTeams"));
504            self.inner.unary(req, path, codec).await
505        }
506        pub async fn add_mng_cluster_provider(
507            &mut self,
508            request: impl tonic::IntoRequest<super::AddMngClusterProviderRequest>,
509        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
510            self.inner
511                .ready()
512                .await
513                .map_err(|e| {
514                    tonic::Status::new(
515                        tonic::Code::Unknown,
516                        format!("Service was not ready: {}", e.into()),
517                    )
518                })?;
519            let codec = tonic::codec::ProstCodec::default();
520            let path = http::uri::PathAndQuery::from_static(
521                "/codegen.ClusterService/AddMngClusterProvider",
522            );
523            let mut req = request.into_request();
524            req.extensions_mut()
525                .insert(
526                    GrpcMethod::new("codegen.ClusterService", "AddMngClusterProvider"),
527                );
528            self.inner.unary(req, path, codec).await
529        }
530        pub async fn add_asg_cluster_provider(
531            &mut self,
532            request: impl tonic::IntoRequest<super::AddAsgClusterProviderRequest>,
533        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
534            self.inner
535                .ready()
536                .await
537                .map_err(|e| {
538                    tonic::Status::new(
539                        tonic::Code::Unknown,
540                        format!("Service was not ready: {}", e.into()),
541                    )
542                })?;
543            let codec = tonic::codec::ProstCodec::default();
544            let path = http::uri::PathAndQuery::from_static(
545                "/codegen.ClusterService/AddAsgClusterProvider",
546            );
547            let mut req = request.into_request();
548            req.extensions_mut()
549                .insert(
550                    GrpcMethod::new("codegen.ClusterService", "AddAsgClusterProvider"),
551                );
552            self.inner.unary(req, path, codec).await
553        }
554        pub async fn add_cluster_provider(
555            &mut self,
556            request: impl tonic::IntoRequest<super::AddClusterProviderRequest>,
557        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
558            self.inner
559                .ready()
560                .await
561                .map_err(|e| {
562                    tonic::Status::new(
563                        tonic::Code::Unknown,
564                        format!("Service was not ready: {}", e.into()),
565                    )
566                })?;
567            let codec = tonic::codec::ProstCodec::default();
568            let path = http::uri::PathAndQuery::from_static(
569                "/codegen.ClusterService/AddClusterProvider",
570            );
571            let mut req = request.into_request();
572            req.extensions_mut()
573                .insert(GrpcMethod::new("codegen.ClusterService", "AddClusterProvider"));
574            self.inner.unary(req, path, codec).await
575        }
576        pub async fn add_vpc_provider(
577            &mut self,
578            request: impl tonic::IntoRequest<super::AddVpcProviderRequest>,
579        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
580            self.inner
581                .ready()
582                .await
583                .map_err(|e| {
584                    tonic::Status::new(
585                        tonic::Code::Unknown,
586                        format!("Service was not ready: {}", e.into()),
587                    )
588                })?;
589            let codec = tonic::codec::ProstCodec::default();
590            let path = http::uri::PathAndQuery::from_static(
591                "/codegen.ClusterService/AddVpcProvider",
592            );
593            let mut req = request.into_request();
594            req.extensions_mut()
595                .insert(GrpcMethod::new("codegen.ClusterService", "AddVpcProvider"));
596            self.inner.unary(req, path, codec).await
597        }
598        pub async fn add_resource_provider(
599            &mut self,
600            request: impl tonic::IntoRequest<super::AddResourceProviderRequest>,
601        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
602            self.inner
603                .ready()
604                .await
605                .map_err(|e| {
606                    tonic::Status::new(
607                        tonic::Code::Unknown,
608                        format!("Service was not ready: {}", e.into()),
609                    )
610                })?;
611            let codec = tonic::codec::ProstCodec::default();
612            let path = http::uri::PathAndQuery::from_static(
613                "/codegen.ClusterService/AddResourceProvider",
614            );
615            let mut req = request.into_request();
616            req.extensions_mut()
617                .insert(
618                    GrpcMethod::new("codegen.ClusterService", "AddResourceProvider"),
619                );
620            self.inner.unary(req, path, codec).await
621        }
622        pub async fn add_ack_add_on(
623            &mut self,
624            request: impl tonic::IntoRequest<super::AddAckAddOnRequest>,
625        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
626            self.inner
627                .ready()
628                .await
629                .map_err(|e| {
630                    tonic::Status::new(
631                        tonic::Code::Unknown,
632                        format!("Service was not ready: {}", e.into()),
633                    )
634                })?;
635            let codec = tonic::codec::ProstCodec::default();
636            let path = http::uri::PathAndQuery::from_static(
637                "/codegen.ClusterService/AddAckAddOn",
638            );
639            let mut req = request.into_request();
640            req.extensions_mut()
641                .insert(GrpcMethod::new("codegen.ClusterService", "AddAckAddOn"));
642            self.inner.unary(req, path, codec).await
643        }
644        pub async fn add_kube_proxy_add_on(
645            &mut self,
646            request: impl tonic::IntoRequest<super::AddKubeProxyAddOnRequest>,
647        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
648            self.inner
649                .ready()
650                .await
651                .map_err(|e| {
652                    tonic::Status::new(
653                        tonic::Code::Unknown,
654                        format!("Service was not ready: {}", e.into()),
655                    )
656                })?;
657            let codec = tonic::codec::ProstCodec::default();
658            let path = http::uri::PathAndQuery::from_static(
659                "/codegen.ClusterService/AddKubeProxyAddOn",
660            );
661            let mut req = request.into_request();
662            req.extensions_mut()
663                .insert(GrpcMethod::new("codegen.ClusterService", "AddKubeProxyAddOn"));
664            self.inner.unary(req, path, codec).await
665        }
666        pub async fn add_core_dns_add_on(
667            &mut self,
668            request: impl tonic::IntoRequest<super::AddCoreDnsAddOnRequest>,
669        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
670            self.inner
671                .ready()
672                .await
673                .map_err(|e| {
674                    tonic::Status::new(
675                        tonic::Code::Unknown,
676                        format!("Service was not ready: {}", e.into()),
677                    )
678                })?;
679            let codec = tonic::codec::ProstCodec::default();
680            let path = http::uri::PathAndQuery::from_static(
681                "/codegen.ClusterService/AddCoreDNSAddOn",
682            );
683            let mut req = request.into_request();
684            req.extensions_mut()
685                .insert(GrpcMethod::new("codegen.ClusterService", "AddCoreDNSAddOn"));
686            self.inner.unary(req, path, codec).await
687        }
688        pub async fn add_metrics_server_add_on(
689            &mut self,
690            request: impl tonic::IntoRequest<super::AddMetricsServerAddOnRequest>,
691        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
692            self.inner
693                .ready()
694                .await
695                .map_err(|e| {
696                    tonic::Status::new(
697                        tonic::Code::Unknown,
698                        format!("Service was not ready: {}", e.into()),
699                    )
700                })?;
701            let codec = tonic::codec::ProstCodec::default();
702            let path = http::uri::PathAndQuery::from_static(
703                "/codegen.ClusterService/AddMetricsServerAddOn",
704            );
705            let mut req = request.into_request();
706            req.extensions_mut()
707                .insert(
708                    GrpcMethod::new("codegen.ClusterService", "AddMetricsServerAddOn"),
709                );
710            self.inner.unary(req, path, codec).await
711        }
712        pub async fn add_addons(
713            &mut self,
714            request: impl tonic::IntoRequest<super::AddAddonsRequest>,
715        ) -> std::result::Result<tonic::Response<super::ApiResponse>, tonic::Status> {
716            self.inner
717                .ready()
718                .await
719                .map_err(|e| {
720                    tonic::Status::new(
721                        tonic::Code::Unknown,
722                        format!("Service was not ready: {}", e.into()),
723                    )
724                })?;
725            let codec = tonic::codec::ProstCodec::default();
726            let path = http::uri::PathAndQuery::from_static(
727                "/codegen.ClusterService/AddAddons",
728            );
729            let mut req = request.into_request();
730            req.extensions_mut()
731                .insert(GrpcMethod::new("codegen.ClusterService", "AddAddons"));
732            self.inner.unary(req, path, codec).await
733        }
734    }
735}
eks_blueprints_rust_sdk/codegen.rs

eks_blueprints_rust_sdk/
codegen.rs
