google_cloud_parametermanager_v1/client.rs
1// Copyright 2025 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// https://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14//
15// Code generated by sidekick. DO NOT EDIT.
16#![allow(rustdoc::bare_urls)]
17#![allow(rustdoc::broken_intra_doc_links)]
18#![allow(rustdoc::invalid_html_tags)]
19#![allow(rustdoc::redundant_explicit_links)]
20
21/// Implements a client for the Parameter Manager API.
22///
23/// # Example
24/// ```
25/// # use google_cloud_parametermanager_v1::client::ParameterManager;
26/// use google_cloud_gax::paginator::ItemPaginator as _;
27/// async fn sample(
28/// project_id: &str,
29/// location_id: &str,
30/// ) -> anyhow::Result<()> {
31/// let client = ParameterManager::builder().build().await?;
32/// let mut list = client.list_parameters()
33/// .set_parent(format!("projects/{project_id}/locations/{location_id}"))
34/// .by_item();
35/// while let Some(item) = list.next().await.transpose()? {
36/// println!("{:?}", item);
37/// }
38/// Ok(())
39/// }
40/// ```
41///
42/// # Service Description
43///
44/// Service describing handlers for resources
45///
46/// # Configuration
47///
48/// To configure `ParameterManager` use the `with_*` methods in the type returned
49/// by [builder()][ParameterManager::builder]. The default configuration should
50/// work for most applications. Common configuration changes include
51///
52/// * [with_endpoint()]: by default this client uses the global default endpoint
53/// (`https://parametermanager.googleapis.com`). Applications using regional
54/// endpoints or running in restricted networks (e.g. a network configured
55/// with [Private Google Access with VPC Service Controls]) may want to
56/// override this default.
57/// * [with_credentials()]: by default this client uses
58/// [Application Default Credentials]. Applications using custom
59/// authentication may need to override this default.
60///
61/// [with_endpoint()]: super::builder::parameter_manager::ClientBuilder::with_endpoint
62/// [with_credentials()]: super::builder::parameter_manager::ClientBuilder::with_credentials
63/// [Private Google Access with VPC Service Controls]: https://cloud.google.com/vpc-service-controls/docs/private-connectivity
64/// [Application Default Credentials]: https://cloud.google.com/docs/authentication#adc
65///
66/// # Pooling and Cloning
67///
68/// `ParameterManager` holds a connection pool internally, it is advised to
69/// create one and reuse it. You do not need to wrap `ParameterManager` in
70/// an [Rc](std::rc::Rc) or [Arc](std::sync::Arc) to reuse it, because it
71/// already uses an `Arc` internally.
72#[derive(Clone, Debug)]
73pub struct ParameterManager {
74 inner: std::sync::Arc<dyn super::stub::dynamic::ParameterManager>,
75}
76
77impl ParameterManager {
78 /// Returns a builder for [ParameterManager].
79 ///
80 /// ```
81 /// # async fn sample() -> google_cloud_gax::client_builder::Result<()> {
82 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
83 /// let client = ParameterManager::builder().build().await?;
84 /// # Ok(()) }
85 /// ```
86 pub fn builder() -> super::builder::parameter_manager::ClientBuilder {
87 crate::new_client_builder(super::builder::parameter_manager::client::Factory)
88 }
89
90 /// Creates a new client from the provided stub.
91 ///
92 /// The most common case for calling this function is in tests mocking the
93 /// client's behavior.
94 pub fn from_stub<T>(stub: impl Into<std::sync::Arc<T>>) -> Self
95 where
96 T: super::stub::ParameterManager + 'static,
97 {
98 Self { inner: stub.into() }
99 }
100
101 pub(crate) async fn new(
102 config: gaxi::options::ClientConfig,
103 ) -> crate::ClientBuilderResult<Self> {
104 let inner = Self::build_inner(config).await?;
105 Ok(Self { inner })
106 }
107
108 async fn build_inner(
109 conf: gaxi::options::ClientConfig,
110 ) -> crate::ClientBuilderResult<std::sync::Arc<dyn super::stub::dynamic::ParameterManager>>
111 {
112 if gaxi::options::tracing_enabled(&conf) {
113 return Ok(std::sync::Arc::new(Self::build_with_tracing(conf).await?));
114 }
115 Ok(std::sync::Arc::new(Self::build_transport(conf).await?))
116 }
117
118 async fn build_transport(
119 conf: gaxi::options::ClientConfig,
120 ) -> crate::ClientBuilderResult<impl super::stub::ParameterManager> {
121 super::transport::ParameterManager::new(conf).await
122 }
123
124 async fn build_with_tracing(
125 conf: gaxi::options::ClientConfig,
126 ) -> crate::ClientBuilderResult<impl super::stub::ParameterManager> {
127 Self::build_transport(conf)
128 .await
129 .map(super::tracing::ParameterManager::new)
130 }
131
132 /// Lists Parameters in a given project and location.
133 ///
134 /// # Example
135 /// ```
136 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
137 /// use google_cloud_gax::paginator::ItemPaginator as _;
138 /// use google_cloud_parametermanager_v1::Result;
139 /// async fn sample(
140 /// client: &ParameterManager, project_id: &str, location_id: &str
141 /// ) -> Result<()> {
142 /// let mut list = client.list_parameters()
143 /// .set_parent(format!("projects/{project_id}/locations/{location_id}"))
144 /// .by_item();
145 /// while let Some(item) = list.next().await.transpose()? {
146 /// println!("{:?}", item);
147 /// }
148 /// Ok(())
149 /// }
150 /// ```
151 pub fn list_parameters(&self) -> super::builder::parameter_manager::ListParameters {
152 super::builder::parameter_manager::ListParameters::new(self.inner.clone())
153 }
154
155 /// Gets details of a single Parameter.
156 ///
157 /// # Example
158 /// ```
159 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
160 /// use google_cloud_parametermanager_v1::Result;
161 /// async fn sample(
162 /// client: &ParameterManager, project_id: &str, location_id: &str, parameter_id: &str
163 /// ) -> Result<()> {
164 /// let response = client.get_parameter()
165 /// .set_name(format!("projects/{project_id}/locations/{location_id}/parameters/{parameter_id}"))
166 /// .send().await?;
167 /// println!("response {:?}", response);
168 /// Ok(())
169 /// }
170 /// ```
171 pub fn get_parameter(&self) -> super::builder::parameter_manager::GetParameter {
172 super::builder::parameter_manager::GetParameter::new(self.inner.clone())
173 }
174
175 /// Creates a new Parameter in a given project and location.
176 ///
177 /// # Example
178 /// ```
179 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
180 /// use google_cloud_parametermanager_v1::model::Parameter;
181 /// use google_cloud_parametermanager_v1::Result;
182 /// async fn sample(
183 /// client: &ParameterManager, project_id: &str, location_id: &str
184 /// ) -> Result<()> {
185 /// let response = client.create_parameter()
186 /// .set_parent(format!("projects/{project_id}/locations/{location_id}"))
187 /// .set_parameter_id("parameter_id_value")
188 /// .set_parameter(
189 /// Parameter::new()/* set fields */
190 /// )
191 /// .send().await?;
192 /// println!("response {:?}", response);
193 /// Ok(())
194 /// }
195 /// ```
196 pub fn create_parameter(&self) -> super::builder::parameter_manager::CreateParameter {
197 super::builder::parameter_manager::CreateParameter::new(self.inner.clone())
198 }
199
200 /// Updates a single Parameter.
201 ///
202 /// # Example
203 /// ```
204 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
205 /// # extern crate wkt as google_cloud_wkt;
206 /// use google_cloud_wkt::FieldMask;
207 /// use google_cloud_parametermanager_v1::model::Parameter;
208 /// use google_cloud_parametermanager_v1::Result;
209 /// async fn sample(
210 /// client: &ParameterManager, project_id: &str, location_id: &str, parameter_id: &str
211 /// ) -> Result<()> {
212 /// let response = client.update_parameter()
213 /// .set_parameter(
214 /// Parameter::new().set_name(format!("projects/{project_id}/locations/{location_id}/parameters/{parameter_id}"))/* set fields */
215 /// )
216 /// .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
217 /// .send().await?;
218 /// println!("response {:?}", response);
219 /// Ok(())
220 /// }
221 /// ```
222 pub fn update_parameter(&self) -> super::builder::parameter_manager::UpdateParameter {
223 super::builder::parameter_manager::UpdateParameter::new(self.inner.clone())
224 }
225
226 /// Deletes a single Parameter.
227 ///
228 /// # Example
229 /// ```
230 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
231 /// use google_cloud_parametermanager_v1::Result;
232 /// async fn sample(
233 /// client: &ParameterManager, project_id: &str, location_id: &str, parameter_id: &str
234 /// ) -> Result<()> {
235 /// client.delete_parameter()
236 /// .set_name(format!("projects/{project_id}/locations/{location_id}/parameters/{parameter_id}"))
237 /// .send().await?;
238 /// Ok(())
239 /// }
240 /// ```
241 pub fn delete_parameter(&self) -> super::builder::parameter_manager::DeleteParameter {
242 super::builder::parameter_manager::DeleteParameter::new(self.inner.clone())
243 }
244
245 /// Lists ParameterVersions in a given project, location, and parameter.
246 ///
247 /// # Example
248 /// ```
249 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
250 /// use google_cloud_gax::paginator::ItemPaginator as _;
251 /// use google_cloud_parametermanager_v1::Result;
252 /// async fn sample(
253 /// client: &ParameterManager, project_id: &str, location_id: &str, parameter_id: &str
254 /// ) -> Result<()> {
255 /// let mut list = client.list_parameter_versions()
256 /// .set_parent(format!("projects/{project_id}/locations/{location_id}/parameters/{parameter_id}"))
257 /// .by_item();
258 /// while let Some(item) = list.next().await.transpose()? {
259 /// println!("{:?}", item);
260 /// }
261 /// Ok(())
262 /// }
263 /// ```
264 pub fn list_parameter_versions(
265 &self,
266 ) -> super::builder::parameter_manager::ListParameterVersions {
267 super::builder::parameter_manager::ListParameterVersions::new(self.inner.clone())
268 }
269
270 /// Gets details of a single ParameterVersion.
271 ///
272 /// # Example
273 /// ```
274 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
275 /// use google_cloud_parametermanager_v1::Result;
276 /// async fn sample(
277 /// client: &ParameterManager, project_id: &str, location_id: &str, parameter_id: &str, parameter_version_id: &str
278 /// ) -> Result<()> {
279 /// let response = client.get_parameter_version()
280 /// .set_name(format!("projects/{project_id}/locations/{location_id}/parameters/{parameter_id}/versions/{parameter_version_id}"))
281 /// .send().await?;
282 /// println!("response {:?}", response);
283 /// Ok(())
284 /// }
285 /// ```
286 pub fn get_parameter_version(&self) -> super::builder::parameter_manager::GetParameterVersion {
287 super::builder::parameter_manager::GetParameterVersion::new(self.inner.clone())
288 }
289
290 /// Gets rendered version of a ParameterVersion.
291 ///
292 /// # Example
293 /// ```
294 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
295 /// use google_cloud_parametermanager_v1::Result;
296 /// async fn sample(
297 /// client: &ParameterManager
298 /// ) -> Result<()> {
299 /// let response = client.render_parameter_version()
300 /// /* set fields */
301 /// .send().await?;
302 /// println!("response {:?}", response);
303 /// Ok(())
304 /// }
305 /// ```
306 pub fn render_parameter_version(
307 &self,
308 ) -> super::builder::parameter_manager::RenderParameterVersion {
309 super::builder::parameter_manager::RenderParameterVersion::new(self.inner.clone())
310 }
311
312 /// Creates a new ParameterVersion in a given project, location, and parameter.
313 ///
314 /// # Example
315 /// ```
316 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
317 /// use google_cloud_parametermanager_v1::model::ParameterVersion;
318 /// use google_cloud_parametermanager_v1::Result;
319 /// async fn sample(
320 /// client: &ParameterManager, project_id: &str, location_id: &str, parameter_id: &str
321 /// ) -> Result<()> {
322 /// let response = client.create_parameter_version()
323 /// .set_parent(format!("projects/{project_id}/locations/{location_id}/parameters/{parameter_id}"))
324 /// .set_parameter_version(
325 /// ParameterVersion::new()/* set fields */
326 /// )
327 /// .send().await?;
328 /// println!("response {:?}", response);
329 /// Ok(())
330 /// }
331 /// ```
332 pub fn create_parameter_version(
333 &self,
334 ) -> super::builder::parameter_manager::CreateParameterVersion {
335 super::builder::parameter_manager::CreateParameterVersion::new(self.inner.clone())
336 }
337
338 /// Updates a single ParameterVersion.
339 ///
340 /// # Example
341 /// ```
342 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
343 /// # extern crate wkt as google_cloud_wkt;
344 /// use google_cloud_wkt::FieldMask;
345 /// use google_cloud_parametermanager_v1::model::ParameterVersion;
346 /// use google_cloud_parametermanager_v1::Result;
347 /// async fn sample(
348 /// client: &ParameterManager, project_id: &str, location_id: &str, parameter_id: &str, parameter_version_id: &str
349 /// ) -> Result<()> {
350 /// let response = client.update_parameter_version()
351 /// .set_parameter_version(
352 /// ParameterVersion::new().set_name(format!("projects/{project_id}/locations/{location_id}/parameters/{parameter_id}/versions/{parameter_version_id}"))/* set fields */
353 /// )
354 /// .set_update_mask(FieldMask::default().set_paths(["updated.field.path1", "updated.field.path2"]))
355 /// .send().await?;
356 /// println!("response {:?}", response);
357 /// Ok(())
358 /// }
359 /// ```
360 pub fn update_parameter_version(
361 &self,
362 ) -> super::builder::parameter_manager::UpdateParameterVersion {
363 super::builder::parameter_manager::UpdateParameterVersion::new(self.inner.clone())
364 }
365
366 /// Deletes a single ParameterVersion.
367 ///
368 /// # Example
369 /// ```
370 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
371 /// use google_cloud_parametermanager_v1::Result;
372 /// async fn sample(
373 /// client: &ParameterManager, project_id: &str, location_id: &str, parameter_id: &str, parameter_version_id: &str
374 /// ) -> Result<()> {
375 /// client.delete_parameter_version()
376 /// .set_name(format!("projects/{project_id}/locations/{location_id}/parameters/{parameter_id}/versions/{parameter_version_id}"))
377 /// .send().await?;
378 /// Ok(())
379 /// }
380 /// ```
381 pub fn delete_parameter_version(
382 &self,
383 ) -> super::builder::parameter_manager::DeleteParameterVersion {
384 super::builder::parameter_manager::DeleteParameterVersion::new(self.inner.clone())
385 }
386
387 /// Lists information about the supported locations for this service.
388 ///
389 /// # Example
390 /// ```
391 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
392 /// use google_cloud_gax::paginator::ItemPaginator as _;
393 /// use google_cloud_parametermanager_v1::Result;
394 /// async fn sample(
395 /// client: &ParameterManager
396 /// ) -> Result<()> {
397 /// let mut list = client.list_locations()
398 /// /* set fields */
399 /// .by_item();
400 /// while let Some(item) = list.next().await.transpose()? {
401 /// println!("{:?}", item);
402 /// }
403 /// Ok(())
404 /// }
405 /// ```
406 pub fn list_locations(&self) -> super::builder::parameter_manager::ListLocations {
407 super::builder::parameter_manager::ListLocations::new(self.inner.clone())
408 }
409
410 /// Gets information about a location.
411 ///
412 /// # Example
413 /// ```
414 /// # use google_cloud_parametermanager_v1::client::ParameterManager;
415 /// use google_cloud_parametermanager_v1::Result;
416 /// async fn sample(
417 /// client: &ParameterManager
418 /// ) -> Result<()> {
419 /// let response = client.get_location()
420 /// /* set fields */
421 /// .send().await?;
422 /// println!("response {:?}", response);
423 /// Ok(())
424 /// }
425 /// ```
426 pub fn get_location(&self) -> super::builder::parameter_manager::GetLocation {
427 super::builder::parameter_manager::GetLocation::new(self.inner.clone())
428 }
429}