1#![allow(unused_mut)]
2#![allow(unused_variables)]
3#![allow(unused_imports)]
4#![allow(clippy::redundant_clone)]
5pub mod models;
6#[derive(Clone)]
7pub struct Client {
8 endpoint: azure_core::Url,
9 credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
10 scopes: Vec<String>,
11 pipeline: azure_core::Pipeline,
12}
13#[derive(Clone)]
14pub struct ClientBuilder {
15 credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
16 endpoint: Option<azure_core::Url>,
17 scopes: Option<Vec<String>>,
18 options: azure_core::ClientOptions,
19}
20pub use azure_core::resource_manager_endpoint::AZURE_PUBLIC_CLOUD as DEFAULT_ENDPOINT;
21impl ClientBuilder {
22 #[doc = "Create a new instance of `ClientBuilder`."]
23 #[must_use]
24 pub fn new(credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>) -> Self {
25 Self {
26 credential,
27 endpoint: None,
28 scopes: None,
29 options: azure_core::ClientOptions::default(),
30 }
31 }
32 #[doc = "Set the endpoint."]
33 #[must_use]
34 pub fn endpoint(mut self, endpoint: impl Into<azure_core::Url>) -> Self {
35 self.endpoint = Some(endpoint.into());
36 self
37 }
38 #[doc = "Set the scopes."]
39 #[must_use]
40 pub fn scopes(mut self, scopes: &[&str]) -> Self {
41 self.scopes = Some(scopes.iter().map(|scope| (*scope).to_owned()).collect());
42 self
43 }
44 #[doc = "Set the retry options."]
45 #[must_use]
46 pub fn retry(mut self, retry: impl Into<azure_core::RetryOptions>) -> Self {
47 self.options = self.options.retry(retry);
48 self
49 }
50 #[doc = "Set the transport options."]
51 #[must_use]
52 pub fn transport(mut self, transport: impl Into<azure_core::TransportOptions>) -> Self {
53 self.options = self.options.transport(transport);
54 self
55 }
56 #[doc = "Convert the builder into a `Client` instance."]
57 pub fn build(self) -> azure_core::Result<Client> {
58 let endpoint = self.endpoint.unwrap_or_else(|| DEFAULT_ENDPOINT.to_owned());
59 let scopes = if let Some(scopes) = self.scopes {
60 scopes
61 } else {
62 vec![endpoint.join(azure_core::auth::DEFAULT_SCOPE_SUFFIX)?.to_string()]
63 };
64 Ok(Client::new(endpoint, self.credential, scopes, self.options))
65 }
66}
67impl Client {
68 pub(crate) async fn bearer_token(&self) -> azure_core::Result<azure_core::auth::Secret> {
69 let credential = self.token_credential();
70 let response = credential.get_token(&self.scopes()).await?;
71 Ok(response.token)
72 }
73 pub(crate) fn endpoint(&self) -> &azure_core::Url {
74 &self.endpoint
75 }
76 pub(crate) fn token_credential(&self) -> &dyn azure_core::auth::TokenCredential {
77 self.credential.as_ref()
78 }
79 pub(crate) fn scopes(&self) -> Vec<&str> {
80 self.scopes.iter().map(String::as_str).collect()
81 }
82 pub(crate) async fn send(&self, request: &mut azure_core::Request) -> azure_core::Result<azure_core::Response> {
83 let context = azure_core::Context::default();
84 self.pipeline.send(&context, request).await
85 }
86 #[doc = "Create a new `ClientBuilder`."]
87 #[must_use]
88 pub fn builder(credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>) -> ClientBuilder {
89 ClientBuilder::new(credential)
90 }
91 #[doc = "Create a new `Client`."]
92 #[must_use]
93 pub fn new(
94 endpoint: impl Into<azure_core::Url>,
95 credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
96 scopes: Vec<String>,
97 options: azure_core::ClientOptions,
98 ) -> Self {
99 let endpoint = endpoint.into();
100 let pipeline = azure_core::Pipeline::new(
101 option_env!("CARGO_PKG_NAME"),
102 option_env!("CARGO_PKG_VERSION"),
103 options,
104 Vec::new(),
105 Vec::new(),
106 );
107 Self {
108 endpoint,
109 credential,
110 scopes,
111 pipeline,
112 }
113 }
114 pub fn configuration_stores_client(&self) -> configuration_stores::Client {
115 configuration_stores::Client(self.clone())
116 }
117 pub fn key_values_client(&self) -> key_values::Client {
118 key_values::Client(self.clone())
119 }
120 pub fn operations_client(&self) -> operations::Client {
121 operations::Client(self.clone())
122 }
123 pub fn private_endpoint_connections_client(&self) -> private_endpoint_connections::Client {
124 private_endpoint_connections::Client(self.clone())
125 }
126 pub fn private_link_resources_client(&self) -> private_link_resources::Client {
127 private_link_resources::Client(self.clone())
128 }
129 pub fn replicas_client(&self) -> replicas::Client {
130 replicas::Client(self.clone())
131 }
132}
133pub mod configuration_stores {
134 use super::models;
135 #[cfg(not(target_arch = "wasm32"))]
136 use futures::future::BoxFuture;
137 #[cfg(target_arch = "wasm32")]
138 use futures::future::LocalBoxFuture as BoxFuture;
139 pub struct Client(pub(crate) super::Client);
140 impl Client {
141 #[doc = "Lists the configuration stores for a given subscription."]
142 #[doc = ""]
143 #[doc = "Arguments:"]
144 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
145 pub fn list(&self, subscription_id: impl Into<String>) -> list::RequestBuilder {
146 list::RequestBuilder {
147 client: self.0.clone(),
148 subscription_id: subscription_id.into(),
149 skip_token: None,
150 }
151 }
152 #[doc = "Lists the configuration stores for a given resource group."]
153 #[doc = ""]
154 #[doc = "Arguments:"]
155 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
156 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
157 pub fn list_by_resource_group(
158 &self,
159 subscription_id: impl Into<String>,
160 resource_group_name: impl Into<String>,
161 ) -> list_by_resource_group::RequestBuilder {
162 list_by_resource_group::RequestBuilder {
163 client: self.0.clone(),
164 subscription_id: subscription_id.into(),
165 resource_group_name: resource_group_name.into(),
166 skip_token: None,
167 }
168 }
169 #[doc = "Gets the properties of the specified configuration store."]
170 #[doc = ""]
171 #[doc = "Arguments:"]
172 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
173 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
174 #[doc = "* `config_store_name`: The name of the configuration store."]
175 pub fn get(
176 &self,
177 subscription_id: impl Into<String>,
178 resource_group_name: impl Into<String>,
179 config_store_name: impl Into<String>,
180 ) -> get::RequestBuilder {
181 get::RequestBuilder {
182 client: self.0.clone(),
183 subscription_id: subscription_id.into(),
184 resource_group_name: resource_group_name.into(),
185 config_store_name: config_store_name.into(),
186 }
187 }
188 #[doc = "Creates a configuration store with the specified parameters."]
189 #[doc = ""]
190 #[doc = "Arguments:"]
191 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
192 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
193 #[doc = "* `config_store_name`: The name of the configuration store."]
194 #[doc = "* `config_store_creation_parameters`: The parameters for creating a configuration store."]
195 pub fn create(
196 &self,
197 subscription_id: impl Into<String>,
198 resource_group_name: impl Into<String>,
199 config_store_name: impl Into<String>,
200 config_store_creation_parameters: impl Into<models::ConfigurationStore>,
201 ) -> create::RequestBuilder {
202 create::RequestBuilder {
203 client: self.0.clone(),
204 subscription_id: subscription_id.into(),
205 resource_group_name: resource_group_name.into(),
206 config_store_name: config_store_name.into(),
207 config_store_creation_parameters: config_store_creation_parameters.into(),
208 }
209 }
210 #[doc = "Updates a configuration store with the specified parameters."]
211 #[doc = ""]
212 #[doc = "Arguments:"]
213 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
214 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
215 #[doc = "* `config_store_name`: The name of the configuration store."]
216 #[doc = "* `config_store_update_parameters`: The parameters for updating a configuration store."]
217 pub fn update(
218 &self,
219 subscription_id: impl Into<String>,
220 resource_group_name: impl Into<String>,
221 config_store_name: impl Into<String>,
222 config_store_update_parameters: impl Into<models::ConfigurationStoreUpdateParameters>,
223 ) -> update::RequestBuilder {
224 update::RequestBuilder {
225 client: self.0.clone(),
226 subscription_id: subscription_id.into(),
227 resource_group_name: resource_group_name.into(),
228 config_store_name: config_store_name.into(),
229 config_store_update_parameters: config_store_update_parameters.into(),
230 }
231 }
232 #[doc = "Deletes a configuration store."]
233 #[doc = ""]
234 #[doc = "Arguments:"]
235 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
236 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
237 #[doc = "* `config_store_name`: The name of the configuration store."]
238 pub fn delete(
239 &self,
240 subscription_id: impl Into<String>,
241 resource_group_name: impl Into<String>,
242 config_store_name: impl Into<String>,
243 ) -> delete::RequestBuilder {
244 delete::RequestBuilder {
245 client: self.0.clone(),
246 subscription_id: subscription_id.into(),
247 resource_group_name: resource_group_name.into(),
248 config_store_name: config_store_name.into(),
249 }
250 }
251 #[doc = "Lists the access key for the specified configuration store."]
252 #[doc = ""]
253 #[doc = "Arguments:"]
254 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
255 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
256 #[doc = "* `config_store_name`: The name of the configuration store."]
257 pub fn list_keys(
258 &self,
259 subscription_id: impl Into<String>,
260 resource_group_name: impl Into<String>,
261 config_store_name: impl Into<String>,
262 ) -> list_keys::RequestBuilder {
263 list_keys::RequestBuilder {
264 client: self.0.clone(),
265 subscription_id: subscription_id.into(),
266 resource_group_name: resource_group_name.into(),
267 config_store_name: config_store_name.into(),
268 skip_token: None,
269 }
270 }
271 #[doc = "Regenerates an access key for the specified configuration store."]
272 #[doc = ""]
273 #[doc = "Arguments:"]
274 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
275 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
276 #[doc = "* `config_store_name`: The name of the configuration store."]
277 #[doc = "* `regenerate_key_parameters`: The parameters for regenerating an access key."]
278 pub fn regenerate_key(
279 &self,
280 subscription_id: impl Into<String>,
281 resource_group_name: impl Into<String>,
282 config_store_name: impl Into<String>,
283 regenerate_key_parameters: impl Into<models::RegenerateKeyParameters>,
284 ) -> regenerate_key::RequestBuilder {
285 regenerate_key::RequestBuilder {
286 client: self.0.clone(),
287 subscription_id: subscription_id.into(),
288 resource_group_name: resource_group_name.into(),
289 config_store_name: config_store_name.into(),
290 regenerate_key_parameters: regenerate_key_parameters.into(),
291 }
292 }
293 #[doc = "Gets information about the deleted configuration stores in a subscription."]
294 #[doc = ""]
295 #[doc = "Arguments:"]
296 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
297 pub fn list_deleted(&self, subscription_id: impl Into<String>) -> list_deleted::RequestBuilder {
298 list_deleted::RequestBuilder {
299 client: self.0.clone(),
300 subscription_id: subscription_id.into(),
301 }
302 }
303 #[doc = "Gets a deleted Azure app configuration store."]
304 #[doc = ""]
305 #[doc = "Arguments:"]
306 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
307 #[doc = "* `location`: The location in which uniqueness will be verified."]
308 #[doc = "* `config_store_name`: The name of the configuration store."]
309 pub fn get_deleted(
310 &self,
311 subscription_id: impl Into<String>,
312 location: impl Into<String>,
313 config_store_name: impl Into<String>,
314 ) -> get_deleted::RequestBuilder {
315 get_deleted::RequestBuilder {
316 client: self.0.clone(),
317 subscription_id: subscription_id.into(),
318 location: location.into(),
319 config_store_name: config_store_name.into(),
320 }
321 }
322 #[doc = "Permanently deletes the specified configuration store."]
323 #[doc = ""]
324 #[doc = "Arguments:"]
325 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
326 #[doc = "* `location`: The location in which uniqueness will be verified."]
327 #[doc = "* `config_store_name`: The name of the configuration store."]
328 pub fn purge_deleted(
329 &self,
330 subscription_id: impl Into<String>,
331 location: impl Into<String>,
332 config_store_name: impl Into<String>,
333 ) -> purge_deleted::RequestBuilder {
334 purge_deleted::RequestBuilder {
335 client: self.0.clone(),
336 subscription_id: subscription_id.into(),
337 location: location.into(),
338 config_store_name: config_store_name.into(),
339 }
340 }
341 }
342 pub mod list {
343 use super::models;
344 #[cfg(not(target_arch = "wasm32"))]
345 use futures::future::BoxFuture;
346 #[cfg(target_arch = "wasm32")]
347 use futures::future::LocalBoxFuture as BoxFuture;
348 #[derive(Debug)]
349 pub struct Response(azure_core::Response);
350 impl Response {
351 pub async fn into_body(self) -> azure_core::Result<models::ConfigurationStoreListResult> {
352 let bytes = self.0.into_body().collect().await?;
353 let body: models::ConfigurationStoreListResult = serde_json::from_slice(&bytes)?;
354 Ok(body)
355 }
356 pub fn into_raw_response(self) -> azure_core::Response {
357 self.0
358 }
359 pub fn as_raw_response(&self) -> &azure_core::Response {
360 &self.0
361 }
362 }
363 impl From<Response> for azure_core::Response {
364 fn from(rsp: Response) -> Self {
365 rsp.into_raw_response()
366 }
367 }
368 impl AsRef<azure_core::Response> for Response {
369 fn as_ref(&self) -> &azure_core::Response {
370 self.as_raw_response()
371 }
372 }
373 #[derive(Clone)]
374 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
375 #[doc = r""]
376 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
377 #[doc = r" parameters can be chained."]
378 #[doc = r""]
379 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
380 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
381 #[doc = r" executes the request and returns a `Result` with the parsed"]
382 #[doc = r" response."]
383 #[doc = r""]
384 #[doc = r" In order to execute the request without polling the service"]
385 #[doc = r" until the operation completes, use `.send().await` instead."]
386 #[doc = r""]
387 #[doc = r" If you need lower-level access to the raw response details"]
388 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
389 #[doc = r" can finalize the request using the"]
390 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
391 #[doc = r" that resolves to a lower-level [`Response`] value."]
392 pub struct RequestBuilder {
393 pub(crate) client: super::super::Client,
394 pub(crate) subscription_id: String,
395 pub(crate) skip_token: Option<String>,
396 }
397 impl RequestBuilder {
398 #[doc = "A skip token is used to continue retrieving items after an operation returns a partial result. If a previous response contains a nextLink element, the value of the nextLink element will include a skipToken parameter that specifies a starting point to use for subsequent calls."]
399 pub fn skip_token(mut self, skip_token: impl Into<String>) -> Self {
400 self.skip_token = Some(skip_token.into());
401 self
402 }
403 pub fn into_stream(self) -> azure_core::Pageable<models::ConfigurationStoreListResult, azure_core::error::Error> {
404 let make_request = move |continuation: Option<String>| {
405 let this = self.clone();
406 async move {
407 let mut url = this.url()?;
408 let rsp = match continuation {
409 Some(value) => {
410 url.set_path("");
411 url = url.join(&value)?;
412 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
413 let bearer_token = this.client.bearer_token().await?;
414 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
415 let has_api_version_already =
416 req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
417 if !has_api_version_already {
418 req.url_mut()
419 .query_pairs_mut()
420 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
421 }
422 let req_body = azure_core::EMPTY_BODY;
423 req.set_body(req_body);
424 this.client.send(&mut req).await?
425 }
426 None => {
427 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
428 let bearer_token = this.client.bearer_token().await?;
429 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
430 if let Some(skip_token) = &this.skip_token {
431 req.url_mut().query_pairs_mut().append_pair("$skipToken", skip_token);
432 }
433 let req_body = azure_core::EMPTY_BODY;
434 req.set_body(req_body);
435 this.client.send(&mut req).await?
436 }
437 };
438 let rsp = match rsp.status() {
439 azure_core::StatusCode::Ok => Ok(Response(rsp)),
440 status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
441 status: status_code,
442 error_code: None,
443 })),
444 };
445 rsp?.into_body().await
446 }
447 };
448 azure_core::Pageable::new(make_request)
449 }
450 fn url(&self) -> azure_core::Result<azure_core::Url> {
451 let mut url = self.client.endpoint().clone();
452 url.set_path(&format!(
453 "/subscriptions/{}/providers/Microsoft.AppConfiguration/configurationStores",
454 &self.subscription_id
455 ));
456 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
457 if !has_api_version_already {
458 url.query_pairs_mut()
459 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
460 }
461 Ok(url)
462 }
463 }
464 }
465 pub mod list_by_resource_group {
466 use super::models;
467 #[cfg(not(target_arch = "wasm32"))]
468 use futures::future::BoxFuture;
469 #[cfg(target_arch = "wasm32")]
470 use futures::future::LocalBoxFuture as BoxFuture;
471 #[derive(Debug)]
472 pub struct Response(azure_core::Response);
473 impl Response {
474 pub async fn into_body(self) -> azure_core::Result<models::ConfigurationStoreListResult> {
475 let bytes = self.0.into_body().collect().await?;
476 let body: models::ConfigurationStoreListResult = serde_json::from_slice(&bytes)?;
477 Ok(body)
478 }
479 pub fn into_raw_response(self) -> azure_core::Response {
480 self.0
481 }
482 pub fn as_raw_response(&self) -> &azure_core::Response {
483 &self.0
484 }
485 }
486 impl From<Response> for azure_core::Response {
487 fn from(rsp: Response) -> Self {
488 rsp.into_raw_response()
489 }
490 }
491 impl AsRef<azure_core::Response> for Response {
492 fn as_ref(&self) -> &azure_core::Response {
493 self.as_raw_response()
494 }
495 }
496 #[derive(Clone)]
497 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
498 #[doc = r""]
499 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
500 #[doc = r" parameters can be chained."]
501 #[doc = r""]
502 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
503 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
504 #[doc = r" executes the request and returns a `Result` with the parsed"]
505 #[doc = r" response."]
506 #[doc = r""]
507 #[doc = r" In order to execute the request without polling the service"]
508 #[doc = r" until the operation completes, use `.send().await` instead."]
509 #[doc = r""]
510 #[doc = r" If you need lower-level access to the raw response details"]
511 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
512 #[doc = r" can finalize the request using the"]
513 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
514 #[doc = r" that resolves to a lower-level [`Response`] value."]
515 pub struct RequestBuilder {
516 pub(crate) client: super::super::Client,
517 pub(crate) subscription_id: String,
518 pub(crate) resource_group_name: String,
519 pub(crate) skip_token: Option<String>,
520 }
521 impl RequestBuilder {
522 #[doc = "A skip token is used to continue retrieving items after an operation returns a partial result. If a previous response contains a nextLink element, the value of the nextLink element will include a skipToken parameter that specifies a starting point to use for subsequent calls."]
523 pub fn skip_token(mut self, skip_token: impl Into<String>) -> Self {
524 self.skip_token = Some(skip_token.into());
525 self
526 }
527 pub fn into_stream(self) -> azure_core::Pageable<models::ConfigurationStoreListResult, azure_core::error::Error> {
528 let make_request = move |continuation: Option<String>| {
529 let this = self.clone();
530 async move {
531 let mut url = this.url()?;
532 let rsp = match continuation {
533 Some(value) => {
534 url.set_path("");
535 url = url.join(&value)?;
536 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
537 let bearer_token = this.client.bearer_token().await?;
538 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
539 let has_api_version_already =
540 req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
541 if !has_api_version_already {
542 req.url_mut()
543 .query_pairs_mut()
544 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
545 }
546 let req_body = azure_core::EMPTY_BODY;
547 req.set_body(req_body);
548 this.client.send(&mut req).await?
549 }
550 None => {
551 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
552 let bearer_token = this.client.bearer_token().await?;
553 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
554 if let Some(skip_token) = &this.skip_token {
555 req.url_mut().query_pairs_mut().append_pair("$skipToken", skip_token);
556 }
557 let req_body = azure_core::EMPTY_BODY;
558 req.set_body(req_body);
559 this.client.send(&mut req).await?
560 }
561 };
562 let rsp = match rsp.status() {
563 azure_core::StatusCode::Ok => Ok(Response(rsp)),
564 status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
565 status: status_code,
566 error_code: None,
567 })),
568 };
569 rsp?.into_body().await
570 }
571 };
572 azure_core::Pageable::new(make_request)
573 }
574 fn url(&self) -> azure_core::Result<azure_core::Url> {
575 let mut url = self.client.endpoint().clone();
576 url.set_path(&format!(
577 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores",
578 &self.subscription_id, &self.resource_group_name
579 ));
580 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
581 if !has_api_version_already {
582 url.query_pairs_mut()
583 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
584 }
585 Ok(url)
586 }
587 }
588 }
589 pub mod get {
590 use super::models;
591 #[cfg(not(target_arch = "wasm32"))]
592 use futures::future::BoxFuture;
593 #[cfg(target_arch = "wasm32")]
594 use futures::future::LocalBoxFuture as BoxFuture;
595 #[derive(Debug)]
596 pub struct Response(azure_core::Response);
597 impl Response {
598 pub async fn into_body(self) -> azure_core::Result<models::ConfigurationStore> {
599 let bytes = self.0.into_body().collect().await?;
600 let body: models::ConfigurationStore = serde_json::from_slice(&bytes)?;
601 Ok(body)
602 }
603 pub fn into_raw_response(self) -> azure_core::Response {
604 self.0
605 }
606 pub fn as_raw_response(&self) -> &azure_core::Response {
607 &self.0
608 }
609 }
610 impl From<Response> for azure_core::Response {
611 fn from(rsp: Response) -> Self {
612 rsp.into_raw_response()
613 }
614 }
615 impl AsRef<azure_core::Response> for Response {
616 fn as_ref(&self) -> &azure_core::Response {
617 self.as_raw_response()
618 }
619 }
620 #[derive(Clone)]
621 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
622 #[doc = r""]
623 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
624 #[doc = r" parameters can be chained."]
625 #[doc = r""]
626 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
627 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
628 #[doc = r" executes the request and returns a `Result` with the parsed"]
629 #[doc = r" response."]
630 #[doc = r""]
631 #[doc = r" In order to execute the request without polling the service"]
632 #[doc = r" until the operation completes, use `.send().await` instead."]
633 #[doc = r""]
634 #[doc = r" If you need lower-level access to the raw response details"]
635 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
636 #[doc = r" can finalize the request using the"]
637 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
638 #[doc = r" that resolves to a lower-level [`Response`] value."]
639 pub struct RequestBuilder {
640 pub(crate) client: super::super::Client,
641 pub(crate) subscription_id: String,
642 pub(crate) resource_group_name: String,
643 pub(crate) config_store_name: String,
644 }
645 impl RequestBuilder {
646 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
647 #[doc = ""]
648 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
649 #[doc = "However, this function can provide more flexibility when required."]
650 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
651 Box::pin({
652 let this = self.clone();
653 async move {
654 let url = this.url()?;
655 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
656 let bearer_token = this.client.bearer_token().await?;
657 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
658 let req_body = azure_core::EMPTY_BODY;
659 req.set_body(req_body);
660 Ok(Response(this.client.send(&mut req).await?))
661 }
662 })
663 }
664 fn url(&self) -> azure_core::Result<azure_core::Url> {
665 let mut url = self.client.endpoint().clone();
666 url.set_path(&format!(
667 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}",
668 &self.subscription_id, &self.resource_group_name, &self.config_store_name
669 ));
670 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
671 if !has_api_version_already {
672 url.query_pairs_mut()
673 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
674 }
675 Ok(url)
676 }
677 }
678 impl std::future::IntoFuture for RequestBuilder {
679 type Output = azure_core::Result<models::ConfigurationStore>;
680 type IntoFuture = BoxFuture<'static, azure_core::Result<models::ConfigurationStore>>;
681 #[doc = "Returns a future that sends the request and returns the parsed response body."]
682 #[doc = ""]
683 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
684 #[doc = ""]
685 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
686 fn into_future(self) -> Self::IntoFuture {
687 Box::pin(async move { self.send().await?.into_body().await })
688 }
689 }
690 }
691 pub mod create {
692 use super::models;
693 #[cfg(not(target_arch = "wasm32"))]
694 use futures::future::BoxFuture;
695 #[cfg(target_arch = "wasm32")]
696 use futures::future::LocalBoxFuture as BoxFuture;
697 #[derive(Debug)]
698 pub struct Response(azure_core::Response);
699 impl Response {
700 pub async fn into_body(self) -> azure_core::Result<models::ConfigurationStore> {
701 let bytes = self.0.into_body().collect().await?;
702 let body: models::ConfigurationStore = serde_json::from_slice(&bytes)?;
703 Ok(body)
704 }
705 pub fn into_raw_response(self) -> azure_core::Response {
706 self.0
707 }
708 pub fn as_raw_response(&self) -> &azure_core::Response {
709 &self.0
710 }
711 }
712 impl From<Response> for azure_core::Response {
713 fn from(rsp: Response) -> Self {
714 rsp.into_raw_response()
715 }
716 }
717 impl AsRef<azure_core::Response> for Response {
718 fn as_ref(&self) -> &azure_core::Response {
719 self.as_raw_response()
720 }
721 }
722 #[derive(Clone)]
723 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
724 #[doc = r""]
725 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
726 #[doc = r" parameters can be chained."]
727 #[doc = r""]
728 #[doc = r" This `RequestBuilder` implements a Long Running Operation"]
729 #[doc = r" (LRO)."]
730 #[doc = r""]
731 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
732 #[doc = r" which will convert the `RequestBuilder` into a future"]
733 #[doc = r" executes the request and polls the service until the"]
734 #[doc = r" operation completes."]
735 #[doc = r""]
736 #[doc = r" In order to execute the request without polling the service"]
737 #[doc = r" until the operation completes, use"]
738 #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"]
739 #[doc = r" [`Response`] value."]
740 pub struct RequestBuilder {
741 pub(crate) client: super::super::Client,
742 pub(crate) subscription_id: String,
743 pub(crate) resource_group_name: String,
744 pub(crate) config_store_name: String,
745 pub(crate) config_store_creation_parameters: models::ConfigurationStore,
746 }
747 impl RequestBuilder {
748 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
749 #[doc = ""]
750 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
751 #[doc = "However, this function can provide more flexibility when required."]
752 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
753 Box::pin({
754 let this = self.clone();
755 async move {
756 let url = this.url()?;
757 let mut req = azure_core::Request::new(url, azure_core::Method::Put);
758 let bearer_token = this.client.bearer_token().await?;
759 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
760 req.insert_header("content-type", "application/json");
761 let req_body = azure_core::to_json(&this.config_store_creation_parameters)?;
762 req.set_body(req_body);
763 Ok(Response(this.client.send(&mut req).await?))
764 }
765 })
766 }
767 fn url(&self) -> azure_core::Result<azure_core::Url> {
768 let mut url = self.client.endpoint().clone();
769 url.set_path(&format!(
770 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}",
771 &self.subscription_id, &self.resource_group_name, &self.config_store_name
772 ));
773 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
774 if !has_api_version_already {
775 url.query_pairs_mut()
776 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
777 }
778 Ok(url)
779 }
780 }
781 impl std::future::IntoFuture for RequestBuilder {
782 type Output = azure_core::Result<models::ConfigurationStore>;
783 type IntoFuture = BoxFuture<'static, azure_core::Result<models::ConfigurationStore>>;
784 #[doc = "Returns a future that polls the long running operation and checks for the state via `properties.provisioningState` in the response body."]
785 #[doc = ""]
786 #[doc = "To only submit the request but not monitor the status of the operation until completion, use `send()` instead."]
787 #[doc = ""]
788 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
789 #[doc = ""]
790 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
791 fn into_future(self) -> Self::IntoFuture {
792 Box::pin(async move {
793 use azure_core::{
794 error::{Error, ErrorKind},
795 lro::{body_content::get_provisioning_state, get_retry_after, LroStatus},
796 sleep::sleep,
797 };
798 use std::time::Duration;
799 loop {
800 let this = self.clone();
801 let response = this.send().await?;
802 let retry_after = get_retry_after(response.as_raw_response().headers());
803 let status = response.as_raw_response().status();
804 let body = response.into_body().await?;
805 let provisioning_state = get_provisioning_state(status, &body)?;
806 log::trace!("current provisioning_state: {provisioning_state:?}");
807 match provisioning_state {
808 LroStatus::Succeeded => return Ok(body),
809 LroStatus::Failed => return Err(Error::message(ErrorKind::Other, "Long running operation failed".to_string())),
810 LroStatus::Canceled => {
811 return Err(Error::message(ErrorKind::Other, "Long running operation canceled".to_string()))
812 }
813 _ => {
814 sleep(retry_after).await;
815 }
816 }
817 }
818 })
819 }
820 }
821 }
822 pub mod update {
823 use super::models;
824 #[cfg(not(target_arch = "wasm32"))]
825 use futures::future::BoxFuture;
826 #[cfg(target_arch = "wasm32")]
827 use futures::future::LocalBoxFuture as BoxFuture;
828 #[derive(Debug)]
829 pub struct Response(azure_core::Response);
830 impl Response {
831 pub async fn into_body(self) -> azure_core::Result<models::ConfigurationStore> {
832 let bytes = self.0.into_body().collect().await?;
833 let body: models::ConfigurationStore = serde_json::from_slice(&bytes)?;
834 Ok(body)
835 }
836 pub fn into_raw_response(self) -> azure_core::Response {
837 self.0
838 }
839 pub fn as_raw_response(&self) -> &azure_core::Response {
840 &self.0
841 }
842 }
843 impl From<Response> for azure_core::Response {
844 fn from(rsp: Response) -> Self {
845 rsp.into_raw_response()
846 }
847 }
848 impl AsRef<azure_core::Response> for Response {
849 fn as_ref(&self) -> &azure_core::Response {
850 self.as_raw_response()
851 }
852 }
853 #[derive(Clone)]
854 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
855 #[doc = r""]
856 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
857 #[doc = r" parameters can be chained."]
858 #[doc = r""]
859 #[doc = r" This `RequestBuilder` implements a Long Running Operation"]
860 #[doc = r" (LRO)."]
861 #[doc = r""]
862 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
863 #[doc = r" which will convert the `RequestBuilder` into a future"]
864 #[doc = r" executes the request and polls the service until the"]
865 #[doc = r" operation completes."]
866 #[doc = r""]
867 #[doc = r" In order to execute the request without polling the service"]
868 #[doc = r" until the operation completes, use"]
869 #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"]
870 #[doc = r" [`Response`] value."]
871 pub struct RequestBuilder {
872 pub(crate) client: super::super::Client,
873 pub(crate) subscription_id: String,
874 pub(crate) resource_group_name: String,
875 pub(crate) config_store_name: String,
876 pub(crate) config_store_update_parameters: models::ConfigurationStoreUpdateParameters,
877 }
878 impl RequestBuilder {
879 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
880 #[doc = ""]
881 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
882 #[doc = "However, this function can provide more flexibility when required."]
883 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
884 Box::pin({
885 let this = self.clone();
886 async move {
887 let url = this.url()?;
888 let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
889 let bearer_token = this.client.bearer_token().await?;
890 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
891 req.insert_header("content-type", "application/json");
892 let req_body = azure_core::to_json(&this.config_store_update_parameters)?;
893 req.set_body(req_body);
894 Ok(Response(this.client.send(&mut req).await?))
895 }
896 })
897 }
898 fn url(&self) -> azure_core::Result<azure_core::Url> {
899 let mut url = self.client.endpoint().clone();
900 url.set_path(&format!(
901 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}",
902 &self.subscription_id, &self.resource_group_name, &self.config_store_name
903 ));
904 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
905 if !has_api_version_already {
906 url.query_pairs_mut()
907 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
908 }
909 Ok(url)
910 }
911 }
912 impl std::future::IntoFuture for RequestBuilder {
913 type Output = azure_core::Result<models::ConfigurationStore>;
914 type IntoFuture = BoxFuture<'static, azure_core::Result<models::ConfigurationStore>>;
915 #[doc = "Returns a future that polls the long running operation and checks for the state via `properties.provisioningState` in the response body."]
916 #[doc = ""]
917 #[doc = "To only submit the request but not monitor the status of the operation until completion, use `send()` instead."]
918 #[doc = ""]
919 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
920 #[doc = ""]
921 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
922 fn into_future(self) -> Self::IntoFuture {
923 Box::pin(async move {
924 use azure_core::{
925 error::{Error, ErrorKind},
926 lro::{body_content::get_provisioning_state, get_retry_after, LroStatus},
927 sleep::sleep,
928 };
929 use std::time::Duration;
930 loop {
931 let this = self.clone();
932 let response = this.send().await?;
933 let retry_after = get_retry_after(response.as_raw_response().headers());
934 let status = response.as_raw_response().status();
935 let body = response.into_body().await?;
936 let provisioning_state = get_provisioning_state(status, &body)?;
937 log::trace!("current provisioning_state: {provisioning_state:?}");
938 match provisioning_state {
939 LroStatus::Succeeded => return Ok(body),
940 LroStatus::Failed => return Err(Error::message(ErrorKind::Other, "Long running operation failed".to_string())),
941 LroStatus::Canceled => {
942 return Err(Error::message(ErrorKind::Other, "Long running operation canceled".to_string()))
943 }
944 _ => {
945 sleep(retry_after).await;
946 }
947 }
948 }
949 })
950 }
951 }
952 }
953 pub mod delete {
954 use super::models;
955 #[cfg(not(target_arch = "wasm32"))]
956 use futures::future::BoxFuture;
957 #[cfg(target_arch = "wasm32")]
958 use futures::future::LocalBoxFuture as BoxFuture;
959 #[derive(Debug)]
960 pub struct Response(azure_core::Response);
961 impl Response {
962 pub fn into_raw_response(self) -> azure_core::Response {
963 self.0
964 }
965 pub fn as_raw_response(&self) -> &azure_core::Response {
966 &self.0
967 }
968 }
969 impl From<Response> for azure_core::Response {
970 fn from(rsp: Response) -> Self {
971 rsp.into_raw_response()
972 }
973 }
974 impl AsRef<azure_core::Response> for Response {
975 fn as_ref(&self) -> &azure_core::Response {
976 self.as_raw_response()
977 }
978 }
979 #[derive(Clone)]
980 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
981 #[doc = r""]
982 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
983 #[doc = r" parameters can be chained."]
984 #[doc = r""]
985 #[doc = r" This `RequestBuilder` implements a Long Running Operation"]
986 #[doc = r" (LRO)."]
987 #[doc = r""]
988 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
989 #[doc = r" which will convert the `RequestBuilder` into a future"]
990 #[doc = r" executes the request and polls the service until the"]
991 #[doc = r" operation completes."]
992 #[doc = r""]
993 #[doc = r" In order to execute the request without polling the service"]
994 #[doc = r" until the operation completes, use"]
995 #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"]
996 #[doc = r" [`Response`] value."]
997 pub struct RequestBuilder {
998 pub(crate) client: super::super::Client,
999 pub(crate) subscription_id: String,
1000 pub(crate) resource_group_name: String,
1001 pub(crate) config_store_name: String,
1002 }
1003 impl RequestBuilder {
1004 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
1005 #[doc = ""]
1006 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
1007 #[doc = "However, this function can provide more flexibility when required."]
1008 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
1009 Box::pin({
1010 let this = self.clone();
1011 async move {
1012 let url = this.url()?;
1013 let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
1014 let bearer_token = this.client.bearer_token().await?;
1015 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
1016 let req_body = azure_core::EMPTY_BODY;
1017 req.set_body(req_body);
1018 Ok(Response(this.client.send(&mut req).await?))
1019 }
1020 })
1021 }
1022 fn url(&self) -> azure_core::Result<azure_core::Url> {
1023 let mut url = self.client.endpoint().clone();
1024 url.set_path(&format!(
1025 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}",
1026 &self.subscription_id, &self.resource_group_name, &self.config_store_name
1027 ));
1028 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
1029 if !has_api_version_already {
1030 url.query_pairs_mut()
1031 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
1032 }
1033 Ok(url)
1034 }
1035 }
1036 }
1037 pub mod list_keys {
1038 use super::models;
1039 #[cfg(not(target_arch = "wasm32"))]
1040 use futures::future::BoxFuture;
1041 #[cfg(target_arch = "wasm32")]
1042 use futures::future::LocalBoxFuture as BoxFuture;
1043 #[derive(Debug)]
1044 pub struct Response(azure_core::Response);
1045 impl Response {
1046 pub async fn into_body(self) -> azure_core::Result<models::ApiKeyListResult> {
1047 let bytes = self.0.into_body().collect().await?;
1048 let body: models::ApiKeyListResult = serde_json::from_slice(&bytes)?;
1049 Ok(body)
1050 }
1051 pub fn into_raw_response(self) -> azure_core::Response {
1052 self.0
1053 }
1054 pub fn as_raw_response(&self) -> &azure_core::Response {
1055 &self.0
1056 }
1057 }
1058 impl From<Response> for azure_core::Response {
1059 fn from(rsp: Response) -> Self {
1060 rsp.into_raw_response()
1061 }
1062 }
1063 impl AsRef<azure_core::Response> for Response {
1064 fn as_ref(&self) -> &azure_core::Response {
1065 self.as_raw_response()
1066 }
1067 }
1068 #[derive(Clone)]
1069 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
1070 #[doc = r""]
1071 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
1072 #[doc = r" parameters can be chained."]
1073 #[doc = r""]
1074 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
1075 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
1076 #[doc = r" executes the request and returns a `Result` with the parsed"]
1077 #[doc = r" response."]
1078 #[doc = r""]
1079 #[doc = r" In order to execute the request without polling the service"]
1080 #[doc = r" until the operation completes, use `.send().await` instead."]
1081 #[doc = r""]
1082 #[doc = r" If you need lower-level access to the raw response details"]
1083 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
1084 #[doc = r" can finalize the request using the"]
1085 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
1086 #[doc = r" that resolves to a lower-level [`Response`] value."]
1087 pub struct RequestBuilder {
1088 pub(crate) client: super::super::Client,
1089 pub(crate) subscription_id: String,
1090 pub(crate) resource_group_name: String,
1091 pub(crate) config_store_name: String,
1092 pub(crate) skip_token: Option<String>,
1093 }
1094 impl RequestBuilder {
1095 #[doc = "A skip token is used to continue retrieving items after an operation returns a partial result. If a previous response contains a nextLink element, the value of the nextLink element will include a skipToken parameter that specifies a starting point to use for subsequent calls."]
1096 pub fn skip_token(mut self, skip_token: impl Into<String>) -> Self {
1097 self.skip_token = Some(skip_token.into());
1098 self
1099 }
1100 pub fn into_stream(self) -> azure_core::Pageable<models::ApiKeyListResult, azure_core::error::Error> {
1101 let make_request = move |continuation: Option<String>| {
1102 let this = self.clone();
1103 async move {
1104 let mut url = this.url()?;
1105 let rsp = match continuation {
1106 Some(value) => {
1107 url.set_path("");
1108 url = url.join(&value)?;
1109 let mut req = azure_core::Request::new(url, azure_core::Method::Post);
1110 let bearer_token = this.client.bearer_token().await?;
1111 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
1112 let has_api_version_already =
1113 req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
1114 if !has_api_version_already {
1115 req.url_mut()
1116 .query_pairs_mut()
1117 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
1118 }
1119 let req_body = azure_core::EMPTY_BODY;
1120 req.set_body(req_body);
1121 this.client.send(&mut req).await?
1122 }
1123 None => {
1124 let mut req = azure_core::Request::new(url, azure_core::Method::Post);
1125 let bearer_token = this.client.bearer_token().await?;
1126 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
1127 if let Some(skip_token) = &this.skip_token {
1128 req.url_mut().query_pairs_mut().append_pair("$skipToken", skip_token);
1129 }
1130 let req_body = azure_core::EMPTY_BODY;
1131 req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
1132 req.set_body(req_body);
1133 this.client.send(&mut req).await?
1134 }
1135 };
1136 let rsp = match rsp.status() {
1137 azure_core::StatusCode::Ok => Ok(Response(rsp)),
1138 status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
1139 status: status_code,
1140 error_code: None,
1141 })),
1142 };
1143 rsp?.into_body().await
1144 }
1145 };
1146 azure_core::Pageable::new(make_request)
1147 }
1148 fn url(&self) -> azure_core::Result<azure_core::Url> {
1149 let mut url = self.client.endpoint().clone();
1150 url.set_path(&format!(
1151 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/listKeys",
1152 &self.subscription_id, &self.resource_group_name, &self.config_store_name
1153 ));
1154 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
1155 if !has_api_version_already {
1156 url.query_pairs_mut()
1157 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
1158 }
1159 Ok(url)
1160 }
1161 }
1162 }
1163 pub mod regenerate_key {
1164 use super::models;
1165 #[cfg(not(target_arch = "wasm32"))]
1166 use futures::future::BoxFuture;
1167 #[cfg(target_arch = "wasm32")]
1168 use futures::future::LocalBoxFuture as BoxFuture;
1169 #[derive(Debug)]
1170 pub struct Response(azure_core::Response);
1171 impl Response {
1172 pub async fn into_body(self) -> azure_core::Result<models::ApiKey> {
1173 let bytes = self.0.into_body().collect().await?;
1174 let body: models::ApiKey = serde_json::from_slice(&bytes)?;
1175 Ok(body)
1176 }
1177 pub fn into_raw_response(self) -> azure_core::Response {
1178 self.0
1179 }
1180 pub fn as_raw_response(&self) -> &azure_core::Response {
1181 &self.0
1182 }
1183 }
1184 impl From<Response> for azure_core::Response {
1185 fn from(rsp: Response) -> Self {
1186 rsp.into_raw_response()
1187 }
1188 }
1189 impl AsRef<azure_core::Response> for Response {
1190 fn as_ref(&self) -> &azure_core::Response {
1191 self.as_raw_response()
1192 }
1193 }
1194 #[derive(Clone)]
1195 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
1196 #[doc = r""]
1197 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
1198 #[doc = r" parameters can be chained."]
1199 #[doc = r""]
1200 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
1201 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
1202 #[doc = r" executes the request and returns a `Result` with the parsed"]
1203 #[doc = r" response."]
1204 #[doc = r""]
1205 #[doc = r" In order to execute the request without polling the service"]
1206 #[doc = r" until the operation completes, use `.send().await` instead."]
1207 #[doc = r""]
1208 #[doc = r" If you need lower-level access to the raw response details"]
1209 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
1210 #[doc = r" can finalize the request using the"]
1211 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
1212 #[doc = r" that resolves to a lower-level [`Response`] value."]
1213 pub struct RequestBuilder {
1214 pub(crate) client: super::super::Client,
1215 pub(crate) subscription_id: String,
1216 pub(crate) resource_group_name: String,
1217 pub(crate) config_store_name: String,
1218 pub(crate) regenerate_key_parameters: models::RegenerateKeyParameters,
1219 }
1220 impl RequestBuilder {
1221 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
1222 #[doc = ""]
1223 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
1224 #[doc = "However, this function can provide more flexibility when required."]
1225 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
1226 Box::pin({
1227 let this = self.clone();
1228 async move {
1229 let url = this.url()?;
1230 let mut req = azure_core::Request::new(url, azure_core::Method::Post);
1231 let bearer_token = this.client.bearer_token().await?;
1232 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
1233 req.insert_header("content-type", "application/json");
1234 let req_body = azure_core::to_json(&this.regenerate_key_parameters)?;
1235 req.set_body(req_body);
1236 Ok(Response(this.client.send(&mut req).await?))
1237 }
1238 })
1239 }
1240 fn url(&self) -> azure_core::Result<azure_core::Url> {
1241 let mut url = self.client.endpoint().clone();
1242 url.set_path(&format!(
1243 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/regenerateKey",
1244 &self.subscription_id, &self.resource_group_name, &self.config_store_name
1245 ));
1246 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
1247 if !has_api_version_already {
1248 url.query_pairs_mut()
1249 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
1250 }
1251 Ok(url)
1252 }
1253 }
1254 impl std::future::IntoFuture for RequestBuilder {
1255 type Output = azure_core::Result<models::ApiKey>;
1256 type IntoFuture = BoxFuture<'static, azure_core::Result<models::ApiKey>>;
1257 #[doc = "Returns a future that sends the request and returns the parsed response body."]
1258 #[doc = ""]
1259 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
1260 #[doc = ""]
1261 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
1262 fn into_future(self) -> Self::IntoFuture {
1263 Box::pin(async move { self.send().await?.into_body().await })
1264 }
1265 }
1266 }
1267 pub mod list_deleted {
1268 use super::models;
1269 #[cfg(not(target_arch = "wasm32"))]
1270 use futures::future::BoxFuture;
1271 #[cfg(target_arch = "wasm32")]
1272 use futures::future::LocalBoxFuture as BoxFuture;
1273 #[derive(Debug)]
1274 pub struct Response(azure_core::Response);
1275 impl Response {
1276 pub async fn into_body(self) -> azure_core::Result<models::DeletedConfigurationStoreListResult> {
1277 let bytes = self.0.into_body().collect().await?;
1278 let body: models::DeletedConfigurationStoreListResult = serde_json::from_slice(&bytes)?;
1279 Ok(body)
1280 }
1281 pub fn into_raw_response(self) -> azure_core::Response {
1282 self.0
1283 }
1284 pub fn as_raw_response(&self) -> &azure_core::Response {
1285 &self.0
1286 }
1287 }
1288 impl From<Response> for azure_core::Response {
1289 fn from(rsp: Response) -> Self {
1290 rsp.into_raw_response()
1291 }
1292 }
1293 impl AsRef<azure_core::Response> for Response {
1294 fn as_ref(&self) -> &azure_core::Response {
1295 self.as_raw_response()
1296 }
1297 }
1298 #[derive(Clone)]
1299 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
1300 #[doc = r""]
1301 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
1302 #[doc = r" parameters can be chained."]
1303 #[doc = r""]
1304 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
1305 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
1306 #[doc = r" executes the request and returns a `Result` with the parsed"]
1307 #[doc = r" response."]
1308 #[doc = r""]
1309 #[doc = r" In order to execute the request without polling the service"]
1310 #[doc = r" until the operation completes, use `.send().await` instead."]
1311 #[doc = r""]
1312 #[doc = r" If you need lower-level access to the raw response details"]
1313 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
1314 #[doc = r" can finalize the request using the"]
1315 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
1316 #[doc = r" that resolves to a lower-level [`Response`] value."]
1317 pub struct RequestBuilder {
1318 pub(crate) client: super::super::Client,
1319 pub(crate) subscription_id: String,
1320 }
1321 impl RequestBuilder {
1322 pub fn into_stream(self) -> azure_core::Pageable<models::DeletedConfigurationStoreListResult, azure_core::error::Error> {
1323 let make_request = move |continuation: Option<String>| {
1324 let this = self.clone();
1325 async move {
1326 let mut url = this.url()?;
1327 let rsp = match continuation {
1328 Some(value) => {
1329 url.set_path("");
1330 url = url.join(&value)?;
1331 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
1332 let bearer_token = this.client.bearer_token().await?;
1333 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
1334 let has_api_version_already =
1335 req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
1336 if !has_api_version_already {
1337 req.url_mut()
1338 .query_pairs_mut()
1339 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
1340 }
1341 let req_body = azure_core::EMPTY_BODY;
1342 req.set_body(req_body);
1343 this.client.send(&mut req).await?
1344 }
1345 None => {
1346 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
1347 let bearer_token = this.client.bearer_token().await?;
1348 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
1349 let req_body = azure_core::EMPTY_BODY;
1350 req.set_body(req_body);
1351 this.client.send(&mut req).await?
1352 }
1353 };
1354 let rsp = match rsp.status() {
1355 azure_core::StatusCode::Ok => Ok(Response(rsp)),
1356 status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
1357 status: status_code,
1358 error_code: None,
1359 })),
1360 };
1361 rsp?.into_body().await
1362 }
1363 };
1364 azure_core::Pageable::new(make_request)
1365 }
1366 fn url(&self) -> azure_core::Result<azure_core::Url> {
1367 let mut url = self.client.endpoint().clone();
1368 url.set_path(&format!(
1369 "/subscriptions/{}/providers/Microsoft.AppConfiguration/deletedConfigurationStores",
1370 &self.subscription_id
1371 ));
1372 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
1373 if !has_api_version_already {
1374 url.query_pairs_mut()
1375 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
1376 }
1377 Ok(url)
1378 }
1379 }
1380 }
1381 pub mod get_deleted {
1382 use super::models;
1383 #[cfg(not(target_arch = "wasm32"))]
1384 use futures::future::BoxFuture;
1385 #[cfg(target_arch = "wasm32")]
1386 use futures::future::LocalBoxFuture as BoxFuture;
1387 #[derive(Debug)]
1388 pub struct Response(azure_core::Response);
1389 impl Response {
1390 pub async fn into_body(self) -> azure_core::Result<models::DeletedConfigurationStore> {
1391 let bytes = self.0.into_body().collect().await?;
1392 let body: models::DeletedConfigurationStore = serde_json::from_slice(&bytes)?;
1393 Ok(body)
1394 }
1395 pub fn into_raw_response(self) -> azure_core::Response {
1396 self.0
1397 }
1398 pub fn as_raw_response(&self) -> &azure_core::Response {
1399 &self.0
1400 }
1401 }
1402 impl From<Response> for azure_core::Response {
1403 fn from(rsp: Response) -> Self {
1404 rsp.into_raw_response()
1405 }
1406 }
1407 impl AsRef<azure_core::Response> for Response {
1408 fn as_ref(&self) -> &azure_core::Response {
1409 self.as_raw_response()
1410 }
1411 }
1412 #[derive(Clone)]
1413 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
1414 #[doc = r""]
1415 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
1416 #[doc = r" parameters can be chained."]
1417 #[doc = r""]
1418 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
1419 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
1420 #[doc = r" executes the request and returns a `Result` with the parsed"]
1421 #[doc = r" response."]
1422 #[doc = r""]
1423 #[doc = r" In order to execute the request without polling the service"]
1424 #[doc = r" until the operation completes, use `.send().await` instead."]
1425 #[doc = r""]
1426 #[doc = r" If you need lower-level access to the raw response details"]
1427 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
1428 #[doc = r" can finalize the request using the"]
1429 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
1430 #[doc = r" that resolves to a lower-level [`Response`] value."]
1431 pub struct RequestBuilder {
1432 pub(crate) client: super::super::Client,
1433 pub(crate) subscription_id: String,
1434 pub(crate) location: String,
1435 pub(crate) config_store_name: String,
1436 }
1437 impl RequestBuilder {
1438 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
1439 #[doc = ""]
1440 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
1441 #[doc = "However, this function can provide more flexibility when required."]
1442 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
1443 Box::pin({
1444 let this = self.clone();
1445 async move {
1446 let url = this.url()?;
1447 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
1448 let bearer_token = this.client.bearer_token().await?;
1449 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
1450 let req_body = azure_core::EMPTY_BODY;
1451 req.set_body(req_body);
1452 Ok(Response(this.client.send(&mut req).await?))
1453 }
1454 })
1455 }
1456 fn url(&self) -> azure_core::Result<azure_core::Url> {
1457 let mut url = self.client.endpoint().clone();
1458 url.set_path(&format!(
1459 "/subscriptions/{}/providers/Microsoft.AppConfiguration/locations/{}/deletedConfigurationStores/{}",
1460 &self.subscription_id, &self.location, &self.config_store_name
1461 ));
1462 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
1463 if !has_api_version_already {
1464 url.query_pairs_mut()
1465 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
1466 }
1467 Ok(url)
1468 }
1469 }
1470 impl std::future::IntoFuture for RequestBuilder {
1471 type Output = azure_core::Result<models::DeletedConfigurationStore>;
1472 type IntoFuture = BoxFuture<'static, azure_core::Result<models::DeletedConfigurationStore>>;
1473 #[doc = "Returns a future that sends the request and returns the parsed response body."]
1474 #[doc = ""]
1475 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
1476 #[doc = ""]
1477 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
1478 fn into_future(self) -> Self::IntoFuture {
1479 Box::pin(async move { self.send().await?.into_body().await })
1480 }
1481 }
1482 }
1483 pub mod purge_deleted {
1484 use super::models;
1485 #[cfg(not(target_arch = "wasm32"))]
1486 use futures::future::BoxFuture;
1487 #[cfg(target_arch = "wasm32")]
1488 use futures::future::LocalBoxFuture as BoxFuture;
1489 #[derive(Debug)]
1490 pub struct Response(azure_core::Response);
1491 impl Response {
1492 pub fn into_raw_response(self) -> azure_core::Response {
1493 self.0
1494 }
1495 pub fn as_raw_response(&self) -> &azure_core::Response {
1496 &self.0
1497 }
1498 }
1499 impl From<Response> for azure_core::Response {
1500 fn from(rsp: Response) -> Self {
1501 rsp.into_raw_response()
1502 }
1503 }
1504 impl AsRef<azure_core::Response> for Response {
1505 fn as_ref(&self) -> &azure_core::Response {
1506 self.as_raw_response()
1507 }
1508 }
1509 #[derive(Clone)]
1510 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
1511 #[doc = r""]
1512 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
1513 #[doc = r" parameters can be chained."]
1514 #[doc = r""]
1515 #[doc = r" This `RequestBuilder` implements a Long Running Operation"]
1516 #[doc = r" (LRO)."]
1517 #[doc = r""]
1518 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
1519 #[doc = r" which will convert the `RequestBuilder` into a future"]
1520 #[doc = r" executes the request and polls the service until the"]
1521 #[doc = r" operation completes."]
1522 #[doc = r""]
1523 #[doc = r" In order to execute the request without polling the service"]
1524 #[doc = r" until the operation completes, use"]
1525 #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"]
1526 #[doc = r" [`Response`] value."]
1527 pub struct RequestBuilder {
1528 pub(crate) client: super::super::Client,
1529 pub(crate) subscription_id: String,
1530 pub(crate) location: String,
1531 pub(crate) config_store_name: String,
1532 }
1533 impl RequestBuilder {
1534 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
1535 #[doc = ""]
1536 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
1537 #[doc = "However, this function can provide more flexibility when required."]
1538 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
1539 Box::pin({
1540 let this = self.clone();
1541 async move {
1542 let url = this.url()?;
1543 let mut req = azure_core::Request::new(url, azure_core::Method::Post);
1544 let bearer_token = this.client.bearer_token().await?;
1545 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
1546 let req_body = azure_core::EMPTY_BODY;
1547 req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
1548 req.set_body(req_body);
1549 Ok(Response(this.client.send(&mut req).await?))
1550 }
1551 })
1552 }
1553 fn url(&self) -> azure_core::Result<azure_core::Url> {
1554 let mut url = self.client.endpoint().clone();
1555 url.set_path(&format!(
1556 "/subscriptions/{}/providers/Microsoft.AppConfiguration/locations/{}/deletedConfigurationStores/{}/purge",
1557 &self.subscription_id, &self.location, &self.config_store_name
1558 ));
1559 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
1560 if !has_api_version_already {
1561 url.query_pairs_mut()
1562 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
1563 }
1564 Ok(url)
1565 }
1566 }
1567 }
1568}
1569pub mod operations {
1570 use super::models;
1571 #[cfg(not(target_arch = "wasm32"))]
1572 use futures::future::BoxFuture;
1573 #[cfg(target_arch = "wasm32")]
1574 use futures::future::LocalBoxFuture as BoxFuture;
1575 pub struct Client(pub(crate) super::Client);
1576 impl Client {
1577 #[doc = "Checks whether the configuration store name is available for use."]
1578 #[doc = ""]
1579 #[doc = "Arguments:"]
1580 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
1581 #[doc = "* `check_name_availability_parameters`: The object containing information for the availability request."]
1582 pub fn check_name_availability(
1583 &self,
1584 subscription_id: impl Into<String>,
1585 check_name_availability_parameters: impl Into<models::CheckNameAvailabilityParameters>,
1586 ) -> check_name_availability::RequestBuilder {
1587 check_name_availability::RequestBuilder {
1588 client: self.0.clone(),
1589 subscription_id: subscription_id.into(),
1590 check_name_availability_parameters: check_name_availability_parameters.into(),
1591 }
1592 }
1593 #[doc = "Lists the operations available from this provider."]
1594 pub fn list(&self) -> list::RequestBuilder {
1595 list::RequestBuilder {
1596 client: self.0.clone(),
1597 skip_token: None,
1598 }
1599 }
1600 #[doc = "Checks whether the configuration store name is available for use."]
1601 #[doc = ""]
1602 #[doc = "Arguments:"]
1603 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
1604 #[doc = "* `location`: The location in which uniqueness will be verified."]
1605 #[doc = "* `check_name_availability_parameters`: The object containing information for the availability request."]
1606 pub fn regional_check_name_availability(
1607 &self,
1608 subscription_id: impl Into<String>,
1609 location: impl Into<String>,
1610 check_name_availability_parameters: impl Into<models::CheckNameAvailabilityParameters>,
1611 ) -> regional_check_name_availability::RequestBuilder {
1612 regional_check_name_availability::RequestBuilder {
1613 client: self.0.clone(),
1614 subscription_id: subscription_id.into(),
1615 location: location.into(),
1616 check_name_availability_parameters: check_name_availability_parameters.into(),
1617 }
1618 }
1619 }
1620 pub mod check_name_availability {
1621 use super::models;
1622 #[cfg(not(target_arch = "wasm32"))]
1623 use futures::future::BoxFuture;
1624 #[cfg(target_arch = "wasm32")]
1625 use futures::future::LocalBoxFuture as BoxFuture;
1626 #[derive(Debug)]
1627 pub struct Response(azure_core::Response);
1628 impl Response {
1629 pub async fn into_body(self) -> azure_core::Result<models::NameAvailabilityStatus> {
1630 let bytes = self.0.into_body().collect().await?;
1631 let body: models::NameAvailabilityStatus = serde_json::from_slice(&bytes)?;
1632 Ok(body)
1633 }
1634 pub fn into_raw_response(self) -> azure_core::Response {
1635 self.0
1636 }
1637 pub fn as_raw_response(&self) -> &azure_core::Response {
1638 &self.0
1639 }
1640 }
1641 impl From<Response> for azure_core::Response {
1642 fn from(rsp: Response) -> Self {
1643 rsp.into_raw_response()
1644 }
1645 }
1646 impl AsRef<azure_core::Response> for Response {
1647 fn as_ref(&self) -> &azure_core::Response {
1648 self.as_raw_response()
1649 }
1650 }
1651 #[derive(Clone)]
1652 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
1653 #[doc = r""]
1654 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
1655 #[doc = r" parameters can be chained."]
1656 #[doc = r""]
1657 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
1658 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
1659 #[doc = r" executes the request and returns a `Result` with the parsed"]
1660 #[doc = r" response."]
1661 #[doc = r""]
1662 #[doc = r" In order to execute the request without polling the service"]
1663 #[doc = r" until the operation completes, use `.send().await` instead."]
1664 #[doc = r""]
1665 #[doc = r" If you need lower-level access to the raw response details"]
1666 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
1667 #[doc = r" can finalize the request using the"]
1668 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
1669 #[doc = r" that resolves to a lower-level [`Response`] value."]
1670 pub struct RequestBuilder {
1671 pub(crate) client: super::super::Client,
1672 pub(crate) subscription_id: String,
1673 pub(crate) check_name_availability_parameters: models::CheckNameAvailabilityParameters,
1674 }
1675 impl RequestBuilder {
1676 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
1677 #[doc = ""]
1678 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
1679 #[doc = "However, this function can provide more flexibility when required."]
1680 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
1681 Box::pin({
1682 let this = self.clone();
1683 async move {
1684 let url = this.url()?;
1685 let mut req = azure_core::Request::new(url, azure_core::Method::Post);
1686 let bearer_token = this.client.bearer_token().await?;
1687 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
1688 req.insert_header("content-type", "application/json");
1689 let req_body = azure_core::to_json(&this.check_name_availability_parameters)?;
1690 req.set_body(req_body);
1691 Ok(Response(this.client.send(&mut req).await?))
1692 }
1693 })
1694 }
1695 fn url(&self) -> azure_core::Result<azure_core::Url> {
1696 let mut url = self.client.endpoint().clone();
1697 url.set_path(&format!(
1698 "/subscriptions/{}/providers/Microsoft.AppConfiguration/checkNameAvailability",
1699 &self.subscription_id
1700 ));
1701 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
1702 if !has_api_version_already {
1703 url.query_pairs_mut()
1704 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
1705 }
1706 Ok(url)
1707 }
1708 }
1709 impl std::future::IntoFuture for RequestBuilder {
1710 type Output = azure_core::Result<models::NameAvailabilityStatus>;
1711 type IntoFuture = BoxFuture<'static, azure_core::Result<models::NameAvailabilityStatus>>;
1712 #[doc = "Returns a future that sends the request and returns the parsed response body."]
1713 #[doc = ""]
1714 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
1715 #[doc = ""]
1716 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
1717 fn into_future(self) -> Self::IntoFuture {
1718 Box::pin(async move { self.send().await?.into_body().await })
1719 }
1720 }
1721 }
1722 pub mod list {
1723 use super::models;
1724 #[cfg(not(target_arch = "wasm32"))]
1725 use futures::future::BoxFuture;
1726 #[cfg(target_arch = "wasm32")]
1727 use futures::future::LocalBoxFuture as BoxFuture;
1728 #[derive(Debug)]
1729 pub struct Response(azure_core::Response);
1730 impl Response {
1731 pub async fn into_body(self) -> azure_core::Result<models::OperationDefinitionListResult> {
1732 let bytes = self.0.into_body().collect().await?;
1733 let body: models::OperationDefinitionListResult = serde_json::from_slice(&bytes)?;
1734 Ok(body)
1735 }
1736 pub fn into_raw_response(self) -> azure_core::Response {
1737 self.0
1738 }
1739 pub fn as_raw_response(&self) -> &azure_core::Response {
1740 &self.0
1741 }
1742 }
1743 impl From<Response> for azure_core::Response {
1744 fn from(rsp: Response) -> Self {
1745 rsp.into_raw_response()
1746 }
1747 }
1748 impl AsRef<azure_core::Response> for Response {
1749 fn as_ref(&self) -> &azure_core::Response {
1750 self.as_raw_response()
1751 }
1752 }
1753 #[derive(Clone)]
1754 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
1755 #[doc = r""]
1756 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
1757 #[doc = r" parameters can be chained."]
1758 #[doc = r""]
1759 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
1760 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
1761 #[doc = r" executes the request and returns a `Result` with the parsed"]
1762 #[doc = r" response."]
1763 #[doc = r""]
1764 #[doc = r" In order to execute the request without polling the service"]
1765 #[doc = r" until the operation completes, use `.send().await` instead."]
1766 #[doc = r""]
1767 #[doc = r" If you need lower-level access to the raw response details"]
1768 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
1769 #[doc = r" can finalize the request using the"]
1770 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
1771 #[doc = r" that resolves to a lower-level [`Response`] value."]
1772 pub struct RequestBuilder {
1773 pub(crate) client: super::super::Client,
1774 pub(crate) skip_token: Option<String>,
1775 }
1776 impl RequestBuilder {
1777 #[doc = "A skip token is used to continue retrieving items after an operation returns a partial result. If a previous response contains a nextLink element, the value of the nextLink element will include a skipToken parameter that specifies a starting point to use for subsequent calls."]
1778 pub fn skip_token(mut self, skip_token: impl Into<String>) -> Self {
1779 self.skip_token = Some(skip_token.into());
1780 self
1781 }
1782 pub fn into_stream(self) -> azure_core::Pageable<models::OperationDefinitionListResult, azure_core::error::Error> {
1783 let make_request = move |continuation: Option<String>| {
1784 let this = self.clone();
1785 async move {
1786 let mut url = this.url()?;
1787 let rsp = match continuation {
1788 Some(value) => {
1789 url.set_path("");
1790 url = url.join(&value)?;
1791 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
1792 let bearer_token = this.client.bearer_token().await?;
1793 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
1794 let has_api_version_already =
1795 req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
1796 if !has_api_version_already {
1797 req.url_mut()
1798 .query_pairs_mut()
1799 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
1800 }
1801 let req_body = azure_core::EMPTY_BODY;
1802 req.set_body(req_body);
1803 this.client.send(&mut req).await?
1804 }
1805 None => {
1806 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
1807 let bearer_token = this.client.bearer_token().await?;
1808 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
1809 if let Some(skip_token) = &this.skip_token {
1810 req.url_mut().query_pairs_mut().append_pair("$skipToken", skip_token);
1811 }
1812 let req_body = azure_core::EMPTY_BODY;
1813 req.set_body(req_body);
1814 this.client.send(&mut req).await?
1815 }
1816 };
1817 let rsp = match rsp.status() {
1818 azure_core::StatusCode::Ok => Ok(Response(rsp)),
1819 status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
1820 status: status_code,
1821 error_code: None,
1822 })),
1823 };
1824 rsp?.into_body().await
1825 }
1826 };
1827 azure_core::Pageable::new(make_request)
1828 }
1829 fn url(&self) -> azure_core::Result<azure_core::Url> {
1830 let mut url = self.client.endpoint().clone();
1831 url.set_path("/providers/Microsoft.AppConfiguration/operations");
1832 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
1833 if !has_api_version_already {
1834 url.query_pairs_mut()
1835 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
1836 }
1837 Ok(url)
1838 }
1839 }
1840 }
1841 pub mod regional_check_name_availability {
1842 use super::models;
1843 #[cfg(not(target_arch = "wasm32"))]
1844 use futures::future::BoxFuture;
1845 #[cfg(target_arch = "wasm32")]
1846 use futures::future::LocalBoxFuture as BoxFuture;
1847 #[derive(Debug)]
1848 pub struct Response(azure_core::Response);
1849 impl Response {
1850 pub async fn into_body(self) -> azure_core::Result<models::NameAvailabilityStatus> {
1851 let bytes = self.0.into_body().collect().await?;
1852 let body: models::NameAvailabilityStatus = serde_json::from_slice(&bytes)?;
1853 Ok(body)
1854 }
1855 pub fn into_raw_response(self) -> azure_core::Response {
1856 self.0
1857 }
1858 pub fn as_raw_response(&self) -> &azure_core::Response {
1859 &self.0
1860 }
1861 }
1862 impl From<Response> for azure_core::Response {
1863 fn from(rsp: Response) -> Self {
1864 rsp.into_raw_response()
1865 }
1866 }
1867 impl AsRef<azure_core::Response> for Response {
1868 fn as_ref(&self) -> &azure_core::Response {
1869 self.as_raw_response()
1870 }
1871 }
1872 #[derive(Clone)]
1873 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
1874 #[doc = r""]
1875 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
1876 #[doc = r" parameters can be chained."]
1877 #[doc = r""]
1878 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
1879 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
1880 #[doc = r" executes the request and returns a `Result` with the parsed"]
1881 #[doc = r" response."]
1882 #[doc = r""]
1883 #[doc = r" In order to execute the request without polling the service"]
1884 #[doc = r" until the operation completes, use `.send().await` instead."]
1885 #[doc = r""]
1886 #[doc = r" If you need lower-level access to the raw response details"]
1887 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
1888 #[doc = r" can finalize the request using the"]
1889 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
1890 #[doc = r" that resolves to a lower-level [`Response`] value."]
1891 pub struct RequestBuilder {
1892 pub(crate) client: super::super::Client,
1893 pub(crate) subscription_id: String,
1894 pub(crate) location: String,
1895 pub(crate) check_name_availability_parameters: models::CheckNameAvailabilityParameters,
1896 }
1897 impl RequestBuilder {
1898 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
1899 #[doc = ""]
1900 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
1901 #[doc = "However, this function can provide more flexibility when required."]
1902 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
1903 Box::pin({
1904 let this = self.clone();
1905 async move {
1906 let url = this.url()?;
1907 let mut req = azure_core::Request::new(url, azure_core::Method::Post);
1908 let bearer_token = this.client.bearer_token().await?;
1909 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
1910 req.insert_header("content-type", "application/json");
1911 let req_body = azure_core::to_json(&this.check_name_availability_parameters)?;
1912 req.set_body(req_body);
1913 Ok(Response(this.client.send(&mut req).await?))
1914 }
1915 })
1916 }
1917 fn url(&self) -> azure_core::Result<azure_core::Url> {
1918 let mut url = self.client.endpoint().clone();
1919 url.set_path(&format!(
1920 "/subscriptions/{}/providers/Microsoft.AppConfiguration/locations/{}/checkNameAvailability",
1921 &self.subscription_id, &self.location
1922 ));
1923 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
1924 if !has_api_version_already {
1925 url.query_pairs_mut()
1926 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
1927 }
1928 Ok(url)
1929 }
1930 }
1931 impl std::future::IntoFuture for RequestBuilder {
1932 type Output = azure_core::Result<models::NameAvailabilityStatus>;
1933 type IntoFuture = BoxFuture<'static, azure_core::Result<models::NameAvailabilityStatus>>;
1934 #[doc = "Returns a future that sends the request and returns the parsed response body."]
1935 #[doc = ""]
1936 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
1937 #[doc = ""]
1938 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
1939 fn into_future(self) -> Self::IntoFuture {
1940 Box::pin(async move { self.send().await?.into_body().await })
1941 }
1942 }
1943 }
1944}
1945pub mod private_endpoint_connections {
1946 use super::models;
1947 #[cfg(not(target_arch = "wasm32"))]
1948 use futures::future::BoxFuture;
1949 #[cfg(target_arch = "wasm32")]
1950 use futures::future::LocalBoxFuture as BoxFuture;
1951 pub struct Client(pub(crate) super::Client);
1952 impl Client {
1953 #[doc = "Lists all private endpoint connections for a configuration store."]
1954 #[doc = ""]
1955 #[doc = "Arguments:"]
1956 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
1957 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
1958 #[doc = "* `config_store_name`: The name of the configuration store."]
1959 pub fn list_by_configuration_store(
1960 &self,
1961 subscription_id: impl Into<String>,
1962 resource_group_name: impl Into<String>,
1963 config_store_name: impl Into<String>,
1964 ) -> list_by_configuration_store::RequestBuilder {
1965 list_by_configuration_store::RequestBuilder {
1966 client: self.0.clone(),
1967 subscription_id: subscription_id.into(),
1968 resource_group_name: resource_group_name.into(),
1969 config_store_name: config_store_name.into(),
1970 }
1971 }
1972 #[doc = "Gets the specified private endpoint connection associated with the configuration store."]
1973 #[doc = ""]
1974 #[doc = "Arguments:"]
1975 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
1976 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
1977 #[doc = "* `config_store_name`: The name of the configuration store."]
1978 #[doc = "* `private_endpoint_connection_name`: Private endpoint connection name"]
1979 pub fn get(
1980 &self,
1981 subscription_id: impl Into<String>,
1982 resource_group_name: impl Into<String>,
1983 config_store_name: impl Into<String>,
1984 private_endpoint_connection_name: impl Into<String>,
1985 ) -> get::RequestBuilder {
1986 get::RequestBuilder {
1987 client: self.0.clone(),
1988 subscription_id: subscription_id.into(),
1989 resource_group_name: resource_group_name.into(),
1990 config_store_name: config_store_name.into(),
1991 private_endpoint_connection_name: private_endpoint_connection_name.into(),
1992 }
1993 }
1994 #[doc = "Update the state of the specified private endpoint connection associated with the configuration store. This operation cannot be used to create a private endpoint connection. Private endpoint connections must be created with the Network resource provider."]
1995 #[doc = ""]
1996 #[doc = "Arguments:"]
1997 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
1998 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
1999 #[doc = "* `config_store_name`: The name of the configuration store."]
2000 #[doc = "* `private_endpoint_connection_name`: Private endpoint connection name"]
2001 #[doc = "* `private_endpoint_connection`: The private endpoint connection properties."]
2002 pub fn create_or_update(
2003 &self,
2004 subscription_id: impl Into<String>,
2005 resource_group_name: impl Into<String>,
2006 config_store_name: impl Into<String>,
2007 private_endpoint_connection_name: impl Into<String>,
2008 private_endpoint_connection: impl Into<models::PrivateEndpointConnection>,
2009 ) -> create_or_update::RequestBuilder {
2010 create_or_update::RequestBuilder {
2011 client: self.0.clone(),
2012 subscription_id: subscription_id.into(),
2013 resource_group_name: resource_group_name.into(),
2014 config_store_name: config_store_name.into(),
2015 private_endpoint_connection_name: private_endpoint_connection_name.into(),
2016 private_endpoint_connection: private_endpoint_connection.into(),
2017 }
2018 }
2019 #[doc = "Deletes a private endpoint connection."]
2020 #[doc = ""]
2021 #[doc = "Arguments:"]
2022 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
2023 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
2024 #[doc = "* `config_store_name`: The name of the configuration store."]
2025 #[doc = "* `private_endpoint_connection_name`: Private endpoint connection name"]
2026 pub fn delete(
2027 &self,
2028 subscription_id: impl Into<String>,
2029 resource_group_name: impl Into<String>,
2030 config_store_name: impl Into<String>,
2031 private_endpoint_connection_name: impl Into<String>,
2032 ) -> delete::RequestBuilder {
2033 delete::RequestBuilder {
2034 client: self.0.clone(),
2035 subscription_id: subscription_id.into(),
2036 resource_group_name: resource_group_name.into(),
2037 config_store_name: config_store_name.into(),
2038 private_endpoint_connection_name: private_endpoint_connection_name.into(),
2039 }
2040 }
2041 }
2042 pub mod list_by_configuration_store {
2043 use super::models;
2044 #[cfg(not(target_arch = "wasm32"))]
2045 use futures::future::BoxFuture;
2046 #[cfg(target_arch = "wasm32")]
2047 use futures::future::LocalBoxFuture as BoxFuture;
2048 #[derive(Debug)]
2049 pub struct Response(azure_core::Response);
2050 impl Response {
2051 pub async fn into_body(self) -> azure_core::Result<models::PrivateEndpointConnectionListResult> {
2052 let bytes = self.0.into_body().collect().await?;
2053 let body: models::PrivateEndpointConnectionListResult = serde_json::from_slice(&bytes)?;
2054 Ok(body)
2055 }
2056 pub fn into_raw_response(self) -> azure_core::Response {
2057 self.0
2058 }
2059 pub fn as_raw_response(&self) -> &azure_core::Response {
2060 &self.0
2061 }
2062 }
2063 impl From<Response> for azure_core::Response {
2064 fn from(rsp: Response) -> Self {
2065 rsp.into_raw_response()
2066 }
2067 }
2068 impl AsRef<azure_core::Response> for Response {
2069 fn as_ref(&self) -> &azure_core::Response {
2070 self.as_raw_response()
2071 }
2072 }
2073 #[derive(Clone)]
2074 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
2075 #[doc = r""]
2076 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
2077 #[doc = r" parameters can be chained."]
2078 #[doc = r""]
2079 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
2080 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
2081 #[doc = r" executes the request and returns a `Result` with the parsed"]
2082 #[doc = r" response."]
2083 #[doc = r""]
2084 #[doc = r" In order to execute the request without polling the service"]
2085 #[doc = r" until the operation completes, use `.send().await` instead."]
2086 #[doc = r""]
2087 #[doc = r" If you need lower-level access to the raw response details"]
2088 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
2089 #[doc = r" can finalize the request using the"]
2090 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
2091 #[doc = r" that resolves to a lower-level [`Response`] value."]
2092 pub struct RequestBuilder {
2093 pub(crate) client: super::super::Client,
2094 pub(crate) subscription_id: String,
2095 pub(crate) resource_group_name: String,
2096 pub(crate) config_store_name: String,
2097 }
2098 impl RequestBuilder {
2099 pub fn into_stream(self) -> azure_core::Pageable<models::PrivateEndpointConnectionListResult, azure_core::error::Error> {
2100 let make_request = move |continuation: Option<String>| {
2101 let this = self.clone();
2102 async move {
2103 let mut url = this.url()?;
2104 let rsp = match continuation {
2105 Some(value) => {
2106 url.set_path("");
2107 url = url.join(&value)?;
2108 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
2109 let bearer_token = this.client.bearer_token().await?;
2110 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
2111 let has_api_version_already =
2112 req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
2113 if !has_api_version_already {
2114 req.url_mut()
2115 .query_pairs_mut()
2116 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
2117 }
2118 let req_body = azure_core::EMPTY_BODY;
2119 req.set_body(req_body);
2120 this.client.send(&mut req).await?
2121 }
2122 None => {
2123 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
2124 let bearer_token = this.client.bearer_token().await?;
2125 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
2126 let req_body = azure_core::EMPTY_BODY;
2127 req.set_body(req_body);
2128 this.client.send(&mut req).await?
2129 }
2130 };
2131 let rsp = match rsp.status() {
2132 azure_core::StatusCode::Ok => Ok(Response(rsp)),
2133 status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
2134 status: status_code,
2135 error_code: None,
2136 })),
2137 };
2138 rsp?.into_body().await
2139 }
2140 };
2141 azure_core::Pageable::new(make_request)
2142 }
2143 fn url(&self) -> azure_core::Result<azure_core::Url> {
2144 let mut url = self.client.endpoint().clone();
2145 url . set_path (& format ! ("/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/privateEndpointConnections" , & self . subscription_id , & self . resource_group_name , & self . config_store_name)) ;
2146 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
2147 if !has_api_version_already {
2148 url.query_pairs_mut()
2149 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
2150 }
2151 Ok(url)
2152 }
2153 }
2154 }
2155 pub mod get {
2156 use super::models;
2157 #[cfg(not(target_arch = "wasm32"))]
2158 use futures::future::BoxFuture;
2159 #[cfg(target_arch = "wasm32")]
2160 use futures::future::LocalBoxFuture as BoxFuture;
2161 #[derive(Debug)]
2162 pub struct Response(azure_core::Response);
2163 impl Response {
2164 pub async fn into_body(self) -> azure_core::Result<models::PrivateEndpointConnection> {
2165 let bytes = self.0.into_body().collect().await?;
2166 let body: models::PrivateEndpointConnection = serde_json::from_slice(&bytes)?;
2167 Ok(body)
2168 }
2169 pub fn into_raw_response(self) -> azure_core::Response {
2170 self.0
2171 }
2172 pub fn as_raw_response(&self) -> &azure_core::Response {
2173 &self.0
2174 }
2175 }
2176 impl From<Response> for azure_core::Response {
2177 fn from(rsp: Response) -> Self {
2178 rsp.into_raw_response()
2179 }
2180 }
2181 impl AsRef<azure_core::Response> for Response {
2182 fn as_ref(&self) -> &azure_core::Response {
2183 self.as_raw_response()
2184 }
2185 }
2186 #[derive(Clone)]
2187 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
2188 #[doc = r""]
2189 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
2190 #[doc = r" parameters can be chained."]
2191 #[doc = r""]
2192 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
2193 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
2194 #[doc = r" executes the request and returns a `Result` with the parsed"]
2195 #[doc = r" response."]
2196 #[doc = r""]
2197 #[doc = r" In order to execute the request without polling the service"]
2198 #[doc = r" until the operation completes, use `.send().await` instead."]
2199 #[doc = r""]
2200 #[doc = r" If you need lower-level access to the raw response details"]
2201 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
2202 #[doc = r" can finalize the request using the"]
2203 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
2204 #[doc = r" that resolves to a lower-level [`Response`] value."]
2205 pub struct RequestBuilder {
2206 pub(crate) client: super::super::Client,
2207 pub(crate) subscription_id: String,
2208 pub(crate) resource_group_name: String,
2209 pub(crate) config_store_name: String,
2210 pub(crate) private_endpoint_connection_name: String,
2211 }
2212 impl RequestBuilder {
2213 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
2214 #[doc = ""]
2215 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
2216 #[doc = "However, this function can provide more flexibility when required."]
2217 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
2218 Box::pin({
2219 let this = self.clone();
2220 async move {
2221 let url = this.url()?;
2222 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
2223 let bearer_token = this.client.bearer_token().await?;
2224 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
2225 let req_body = azure_core::EMPTY_BODY;
2226 req.set_body(req_body);
2227 Ok(Response(this.client.send(&mut req).await?))
2228 }
2229 })
2230 }
2231 fn url(&self) -> azure_core::Result<azure_core::Url> {
2232 let mut url = self.client.endpoint().clone();
2233 url . set_path (& format ! ("/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/privateEndpointConnections/{}" , & self . subscription_id , & self . resource_group_name , & self . config_store_name , & self . private_endpoint_connection_name)) ;
2234 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
2235 if !has_api_version_already {
2236 url.query_pairs_mut()
2237 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
2238 }
2239 Ok(url)
2240 }
2241 }
2242 impl std::future::IntoFuture for RequestBuilder {
2243 type Output = azure_core::Result<models::PrivateEndpointConnection>;
2244 type IntoFuture = BoxFuture<'static, azure_core::Result<models::PrivateEndpointConnection>>;
2245 #[doc = "Returns a future that sends the request and returns the parsed response body."]
2246 #[doc = ""]
2247 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
2248 #[doc = ""]
2249 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
2250 fn into_future(self) -> Self::IntoFuture {
2251 Box::pin(async move { self.send().await?.into_body().await })
2252 }
2253 }
2254 }
2255 pub mod create_or_update {
2256 use super::models;
2257 #[cfg(not(target_arch = "wasm32"))]
2258 use futures::future::BoxFuture;
2259 #[cfg(target_arch = "wasm32")]
2260 use futures::future::LocalBoxFuture as BoxFuture;
2261 #[derive(Debug)]
2262 pub struct Response(azure_core::Response);
2263 impl Response {
2264 pub async fn into_body(self) -> azure_core::Result<models::PrivateEndpointConnection> {
2265 let bytes = self.0.into_body().collect().await?;
2266 let body: models::PrivateEndpointConnection = serde_json::from_slice(&bytes)?;
2267 Ok(body)
2268 }
2269 pub fn into_raw_response(self) -> azure_core::Response {
2270 self.0
2271 }
2272 pub fn as_raw_response(&self) -> &azure_core::Response {
2273 &self.0
2274 }
2275 }
2276 impl From<Response> for azure_core::Response {
2277 fn from(rsp: Response) -> Self {
2278 rsp.into_raw_response()
2279 }
2280 }
2281 impl AsRef<azure_core::Response> for Response {
2282 fn as_ref(&self) -> &azure_core::Response {
2283 self.as_raw_response()
2284 }
2285 }
2286 #[derive(Clone)]
2287 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
2288 #[doc = r""]
2289 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
2290 #[doc = r" parameters can be chained."]
2291 #[doc = r""]
2292 #[doc = r" This `RequestBuilder` implements a Long Running Operation"]
2293 #[doc = r" (LRO)."]
2294 #[doc = r""]
2295 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
2296 #[doc = r" which will convert the `RequestBuilder` into a future"]
2297 #[doc = r" executes the request and polls the service until the"]
2298 #[doc = r" operation completes."]
2299 #[doc = r""]
2300 #[doc = r" In order to execute the request without polling the service"]
2301 #[doc = r" until the operation completes, use"]
2302 #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"]
2303 #[doc = r" [`Response`] value."]
2304 pub struct RequestBuilder {
2305 pub(crate) client: super::super::Client,
2306 pub(crate) subscription_id: String,
2307 pub(crate) resource_group_name: String,
2308 pub(crate) config_store_name: String,
2309 pub(crate) private_endpoint_connection_name: String,
2310 pub(crate) private_endpoint_connection: models::PrivateEndpointConnection,
2311 }
2312 impl RequestBuilder {
2313 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
2314 #[doc = ""]
2315 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
2316 #[doc = "However, this function can provide more flexibility when required."]
2317 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
2318 Box::pin({
2319 let this = self.clone();
2320 async move {
2321 let url = this.url()?;
2322 let mut req = azure_core::Request::new(url, azure_core::Method::Put);
2323 let bearer_token = this.client.bearer_token().await?;
2324 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
2325 req.insert_header("content-type", "application/json");
2326 let req_body = azure_core::to_json(&this.private_endpoint_connection)?;
2327 req.set_body(req_body);
2328 Ok(Response(this.client.send(&mut req).await?))
2329 }
2330 })
2331 }
2332 fn url(&self) -> azure_core::Result<azure_core::Url> {
2333 let mut url = self.client.endpoint().clone();
2334 url . set_path (& format ! ("/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/privateEndpointConnections/{}" , & self . subscription_id , & self . resource_group_name , & self . config_store_name , & self . private_endpoint_connection_name)) ;
2335 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
2336 if !has_api_version_already {
2337 url.query_pairs_mut()
2338 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
2339 }
2340 Ok(url)
2341 }
2342 }
2343 impl std::future::IntoFuture for RequestBuilder {
2344 type Output = azure_core::Result<models::PrivateEndpointConnection>;
2345 type IntoFuture = BoxFuture<'static, azure_core::Result<models::PrivateEndpointConnection>>;
2346 #[doc = "Returns a future that polls the long running operation and checks for the state via `properties.provisioningState` in the response body."]
2347 #[doc = ""]
2348 #[doc = "To only submit the request but not monitor the status of the operation until completion, use `send()` instead."]
2349 #[doc = ""]
2350 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
2351 #[doc = ""]
2352 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
2353 fn into_future(self) -> Self::IntoFuture {
2354 Box::pin(async move {
2355 use azure_core::{
2356 error::{Error, ErrorKind},
2357 lro::{body_content::get_provisioning_state, get_retry_after, LroStatus},
2358 sleep::sleep,
2359 };
2360 use std::time::Duration;
2361 loop {
2362 let this = self.clone();
2363 let response = this.send().await?;
2364 let retry_after = get_retry_after(response.as_raw_response().headers());
2365 let status = response.as_raw_response().status();
2366 let body = response.into_body().await?;
2367 let provisioning_state = get_provisioning_state(status, &body)?;
2368 log::trace!("current provisioning_state: {provisioning_state:?}");
2369 match provisioning_state {
2370 LroStatus::Succeeded => return Ok(body),
2371 LroStatus::Failed => return Err(Error::message(ErrorKind::Other, "Long running operation failed".to_string())),
2372 LroStatus::Canceled => {
2373 return Err(Error::message(ErrorKind::Other, "Long running operation canceled".to_string()))
2374 }
2375 _ => {
2376 sleep(retry_after).await;
2377 }
2378 }
2379 }
2380 })
2381 }
2382 }
2383 }
2384 pub mod delete {
2385 use super::models;
2386 #[cfg(not(target_arch = "wasm32"))]
2387 use futures::future::BoxFuture;
2388 #[cfg(target_arch = "wasm32")]
2389 use futures::future::LocalBoxFuture as BoxFuture;
2390 #[derive(Debug)]
2391 pub struct Response(azure_core::Response);
2392 impl Response {
2393 pub fn into_raw_response(self) -> azure_core::Response {
2394 self.0
2395 }
2396 pub fn as_raw_response(&self) -> &azure_core::Response {
2397 &self.0
2398 }
2399 }
2400 impl From<Response> for azure_core::Response {
2401 fn from(rsp: Response) -> Self {
2402 rsp.into_raw_response()
2403 }
2404 }
2405 impl AsRef<azure_core::Response> for Response {
2406 fn as_ref(&self) -> &azure_core::Response {
2407 self.as_raw_response()
2408 }
2409 }
2410 #[derive(Clone)]
2411 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
2412 #[doc = r""]
2413 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
2414 #[doc = r" parameters can be chained."]
2415 #[doc = r""]
2416 #[doc = r" This `RequestBuilder` implements a Long Running Operation"]
2417 #[doc = r" (LRO)."]
2418 #[doc = r""]
2419 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
2420 #[doc = r" which will convert the `RequestBuilder` into a future"]
2421 #[doc = r" executes the request and polls the service until the"]
2422 #[doc = r" operation completes."]
2423 #[doc = r""]
2424 #[doc = r" In order to execute the request without polling the service"]
2425 #[doc = r" until the operation completes, use"]
2426 #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"]
2427 #[doc = r" [`Response`] value."]
2428 pub struct RequestBuilder {
2429 pub(crate) client: super::super::Client,
2430 pub(crate) subscription_id: String,
2431 pub(crate) resource_group_name: String,
2432 pub(crate) config_store_name: String,
2433 pub(crate) private_endpoint_connection_name: String,
2434 }
2435 impl RequestBuilder {
2436 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
2437 #[doc = ""]
2438 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
2439 #[doc = "However, this function can provide more flexibility when required."]
2440 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
2441 Box::pin({
2442 let this = self.clone();
2443 async move {
2444 let url = this.url()?;
2445 let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
2446 let bearer_token = this.client.bearer_token().await?;
2447 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
2448 let req_body = azure_core::EMPTY_BODY;
2449 req.set_body(req_body);
2450 Ok(Response(this.client.send(&mut req).await?))
2451 }
2452 })
2453 }
2454 fn url(&self) -> azure_core::Result<azure_core::Url> {
2455 let mut url = self.client.endpoint().clone();
2456 url . set_path (& format ! ("/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/privateEndpointConnections/{}" , & self . subscription_id , & self . resource_group_name , & self . config_store_name , & self . private_endpoint_connection_name)) ;
2457 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
2458 if !has_api_version_already {
2459 url.query_pairs_mut()
2460 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
2461 }
2462 Ok(url)
2463 }
2464 }
2465 }
2466}
2467pub mod private_link_resources {
2468 use super::models;
2469 #[cfg(not(target_arch = "wasm32"))]
2470 use futures::future::BoxFuture;
2471 #[cfg(target_arch = "wasm32")]
2472 use futures::future::LocalBoxFuture as BoxFuture;
2473 pub struct Client(pub(crate) super::Client);
2474 impl Client {
2475 #[doc = "Gets the private link resources that need to be created for a configuration store."]
2476 #[doc = ""]
2477 #[doc = "Arguments:"]
2478 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
2479 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
2480 #[doc = "* `config_store_name`: The name of the configuration store."]
2481 pub fn list_by_configuration_store(
2482 &self,
2483 subscription_id: impl Into<String>,
2484 resource_group_name: impl Into<String>,
2485 config_store_name: impl Into<String>,
2486 ) -> list_by_configuration_store::RequestBuilder {
2487 list_by_configuration_store::RequestBuilder {
2488 client: self.0.clone(),
2489 subscription_id: subscription_id.into(),
2490 resource_group_name: resource_group_name.into(),
2491 config_store_name: config_store_name.into(),
2492 }
2493 }
2494 #[doc = "Gets a private link resource that need to be created for a configuration store."]
2495 #[doc = ""]
2496 #[doc = "Arguments:"]
2497 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
2498 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
2499 #[doc = "* `config_store_name`: The name of the configuration store."]
2500 #[doc = "* `group_name`: The name of the private link resource group."]
2501 pub fn get(
2502 &self,
2503 subscription_id: impl Into<String>,
2504 resource_group_name: impl Into<String>,
2505 config_store_name: impl Into<String>,
2506 group_name: impl Into<String>,
2507 ) -> get::RequestBuilder {
2508 get::RequestBuilder {
2509 client: self.0.clone(),
2510 subscription_id: subscription_id.into(),
2511 resource_group_name: resource_group_name.into(),
2512 config_store_name: config_store_name.into(),
2513 group_name: group_name.into(),
2514 }
2515 }
2516 }
2517 pub mod list_by_configuration_store {
2518 use super::models;
2519 #[cfg(not(target_arch = "wasm32"))]
2520 use futures::future::BoxFuture;
2521 #[cfg(target_arch = "wasm32")]
2522 use futures::future::LocalBoxFuture as BoxFuture;
2523 #[derive(Debug)]
2524 pub struct Response(azure_core::Response);
2525 impl Response {
2526 pub async fn into_body(self) -> azure_core::Result<models::PrivateLinkResourceListResult> {
2527 let bytes = self.0.into_body().collect().await?;
2528 let body: models::PrivateLinkResourceListResult = serde_json::from_slice(&bytes)?;
2529 Ok(body)
2530 }
2531 pub fn into_raw_response(self) -> azure_core::Response {
2532 self.0
2533 }
2534 pub fn as_raw_response(&self) -> &azure_core::Response {
2535 &self.0
2536 }
2537 }
2538 impl From<Response> for azure_core::Response {
2539 fn from(rsp: Response) -> Self {
2540 rsp.into_raw_response()
2541 }
2542 }
2543 impl AsRef<azure_core::Response> for Response {
2544 fn as_ref(&self) -> &azure_core::Response {
2545 self.as_raw_response()
2546 }
2547 }
2548 #[derive(Clone)]
2549 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
2550 #[doc = r""]
2551 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
2552 #[doc = r" parameters can be chained."]
2553 #[doc = r""]
2554 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
2555 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
2556 #[doc = r" executes the request and returns a `Result` with the parsed"]
2557 #[doc = r" response."]
2558 #[doc = r""]
2559 #[doc = r" In order to execute the request without polling the service"]
2560 #[doc = r" until the operation completes, use `.send().await` instead."]
2561 #[doc = r""]
2562 #[doc = r" If you need lower-level access to the raw response details"]
2563 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
2564 #[doc = r" can finalize the request using the"]
2565 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
2566 #[doc = r" that resolves to a lower-level [`Response`] value."]
2567 pub struct RequestBuilder {
2568 pub(crate) client: super::super::Client,
2569 pub(crate) subscription_id: String,
2570 pub(crate) resource_group_name: String,
2571 pub(crate) config_store_name: String,
2572 }
2573 impl RequestBuilder {
2574 pub fn into_stream(self) -> azure_core::Pageable<models::PrivateLinkResourceListResult, azure_core::error::Error> {
2575 let make_request = move |continuation: Option<String>| {
2576 let this = self.clone();
2577 async move {
2578 let mut url = this.url()?;
2579 let rsp = match continuation {
2580 Some(value) => {
2581 url.set_path("");
2582 url = url.join(&value)?;
2583 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
2584 let bearer_token = this.client.bearer_token().await?;
2585 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
2586 let has_api_version_already =
2587 req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
2588 if !has_api_version_already {
2589 req.url_mut()
2590 .query_pairs_mut()
2591 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
2592 }
2593 let req_body = azure_core::EMPTY_BODY;
2594 req.set_body(req_body);
2595 this.client.send(&mut req).await?
2596 }
2597 None => {
2598 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
2599 let bearer_token = this.client.bearer_token().await?;
2600 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
2601 let req_body = azure_core::EMPTY_BODY;
2602 req.set_body(req_body);
2603 this.client.send(&mut req).await?
2604 }
2605 };
2606 let rsp = match rsp.status() {
2607 azure_core::StatusCode::Ok => Ok(Response(rsp)),
2608 status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
2609 status: status_code,
2610 error_code: None,
2611 })),
2612 };
2613 rsp?.into_body().await
2614 }
2615 };
2616 azure_core::Pageable::new(make_request)
2617 }
2618 fn url(&self) -> azure_core::Result<azure_core::Url> {
2619 let mut url = self.client.endpoint().clone();
2620 url.set_path(&format!(
2621 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/privateLinkResources",
2622 &self.subscription_id, &self.resource_group_name, &self.config_store_name
2623 ));
2624 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
2625 if !has_api_version_already {
2626 url.query_pairs_mut()
2627 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
2628 }
2629 Ok(url)
2630 }
2631 }
2632 }
2633 pub mod get {
2634 use super::models;
2635 #[cfg(not(target_arch = "wasm32"))]
2636 use futures::future::BoxFuture;
2637 #[cfg(target_arch = "wasm32")]
2638 use futures::future::LocalBoxFuture as BoxFuture;
2639 #[derive(Debug)]
2640 pub struct Response(azure_core::Response);
2641 impl Response {
2642 pub async fn into_body(self) -> azure_core::Result<models::PrivateLinkResource> {
2643 let bytes = self.0.into_body().collect().await?;
2644 let body: models::PrivateLinkResource = serde_json::from_slice(&bytes)?;
2645 Ok(body)
2646 }
2647 pub fn into_raw_response(self) -> azure_core::Response {
2648 self.0
2649 }
2650 pub fn as_raw_response(&self) -> &azure_core::Response {
2651 &self.0
2652 }
2653 }
2654 impl From<Response> for azure_core::Response {
2655 fn from(rsp: Response) -> Self {
2656 rsp.into_raw_response()
2657 }
2658 }
2659 impl AsRef<azure_core::Response> for Response {
2660 fn as_ref(&self) -> &azure_core::Response {
2661 self.as_raw_response()
2662 }
2663 }
2664 #[derive(Clone)]
2665 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
2666 #[doc = r""]
2667 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
2668 #[doc = r" parameters can be chained."]
2669 #[doc = r""]
2670 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
2671 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
2672 #[doc = r" executes the request and returns a `Result` with the parsed"]
2673 #[doc = r" response."]
2674 #[doc = r""]
2675 #[doc = r" In order to execute the request without polling the service"]
2676 #[doc = r" until the operation completes, use `.send().await` instead."]
2677 #[doc = r""]
2678 #[doc = r" If you need lower-level access to the raw response details"]
2679 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
2680 #[doc = r" can finalize the request using the"]
2681 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
2682 #[doc = r" that resolves to a lower-level [`Response`] value."]
2683 pub struct RequestBuilder {
2684 pub(crate) client: super::super::Client,
2685 pub(crate) subscription_id: String,
2686 pub(crate) resource_group_name: String,
2687 pub(crate) config_store_name: String,
2688 pub(crate) group_name: String,
2689 }
2690 impl RequestBuilder {
2691 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
2692 #[doc = ""]
2693 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
2694 #[doc = "However, this function can provide more flexibility when required."]
2695 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
2696 Box::pin({
2697 let this = self.clone();
2698 async move {
2699 let url = this.url()?;
2700 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
2701 let bearer_token = this.client.bearer_token().await?;
2702 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
2703 let req_body = azure_core::EMPTY_BODY;
2704 req.set_body(req_body);
2705 Ok(Response(this.client.send(&mut req).await?))
2706 }
2707 })
2708 }
2709 fn url(&self) -> azure_core::Result<azure_core::Url> {
2710 let mut url = self.client.endpoint().clone();
2711 url . set_path (& format ! ("/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/privateLinkResources/{}" , & self . subscription_id , & self . resource_group_name , & self . config_store_name , & self . group_name)) ;
2712 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
2713 if !has_api_version_already {
2714 url.query_pairs_mut()
2715 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
2716 }
2717 Ok(url)
2718 }
2719 }
2720 impl std::future::IntoFuture for RequestBuilder {
2721 type Output = azure_core::Result<models::PrivateLinkResource>;
2722 type IntoFuture = BoxFuture<'static, azure_core::Result<models::PrivateLinkResource>>;
2723 #[doc = "Returns a future that sends the request and returns the parsed response body."]
2724 #[doc = ""]
2725 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
2726 #[doc = ""]
2727 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
2728 fn into_future(self) -> Self::IntoFuture {
2729 Box::pin(async move { self.send().await?.into_body().await })
2730 }
2731 }
2732 }
2733}
2734pub mod key_values {
2735 use super::models;
2736 #[cfg(not(target_arch = "wasm32"))]
2737 use futures::future::BoxFuture;
2738 #[cfg(target_arch = "wasm32")]
2739 use futures::future::LocalBoxFuture as BoxFuture;
2740 pub struct Client(pub(crate) super::Client);
2741 impl Client {
2742 #[doc = "Gets the properties of the specified key-value. NOTE: This operation is intended for use in ARM Template deployments. For all other scenarios involving App Configuration key-values the data plane API should be used instead."]
2743 #[doc = ""]
2744 #[doc = "Arguments:"]
2745 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
2746 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
2747 #[doc = "* `config_store_name`: The name of the configuration store."]
2748 #[doc = "* `key_value_name`: Identifier of key and label combination. Key and label are joined by $ character. Label is optional."]
2749 pub fn get(
2750 &self,
2751 subscription_id: impl Into<String>,
2752 resource_group_name: impl Into<String>,
2753 config_store_name: impl Into<String>,
2754 key_value_name: impl Into<String>,
2755 ) -> get::RequestBuilder {
2756 get::RequestBuilder {
2757 client: self.0.clone(),
2758 subscription_id: subscription_id.into(),
2759 resource_group_name: resource_group_name.into(),
2760 config_store_name: config_store_name.into(),
2761 key_value_name: key_value_name.into(),
2762 }
2763 }
2764 #[doc = "Creates a key-value. NOTE: This operation is intended for use in ARM Template deployments. For all other scenarios involving App Configuration key-values the data plane API should be used instead."]
2765 #[doc = ""]
2766 #[doc = "Arguments:"]
2767 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
2768 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
2769 #[doc = "* `config_store_name`: The name of the configuration store."]
2770 #[doc = "* `key_value_name`: Identifier of key and label combination. Key and label are joined by $ character. Label is optional."]
2771 pub fn create_or_update(
2772 &self,
2773 subscription_id: impl Into<String>,
2774 resource_group_name: impl Into<String>,
2775 config_store_name: impl Into<String>,
2776 key_value_name: impl Into<String>,
2777 ) -> create_or_update::RequestBuilder {
2778 create_or_update::RequestBuilder {
2779 client: self.0.clone(),
2780 subscription_id: subscription_id.into(),
2781 resource_group_name: resource_group_name.into(),
2782 config_store_name: config_store_name.into(),
2783 key_value_name: key_value_name.into(),
2784 key_value_parameters: None,
2785 }
2786 }
2787 #[doc = "Deletes a key-value. NOTE: This operation is intended for use in ARM Template deployments. For all other scenarios involving App Configuration key-values the data plane API should be used instead."]
2788 #[doc = ""]
2789 #[doc = "Arguments:"]
2790 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
2791 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
2792 #[doc = "* `config_store_name`: The name of the configuration store."]
2793 #[doc = "* `key_value_name`: Identifier of key and label combination. Key and label are joined by $ character. Label is optional."]
2794 pub fn delete(
2795 &self,
2796 subscription_id: impl Into<String>,
2797 resource_group_name: impl Into<String>,
2798 config_store_name: impl Into<String>,
2799 key_value_name: impl Into<String>,
2800 ) -> delete::RequestBuilder {
2801 delete::RequestBuilder {
2802 client: self.0.clone(),
2803 subscription_id: subscription_id.into(),
2804 resource_group_name: resource_group_name.into(),
2805 config_store_name: config_store_name.into(),
2806 key_value_name: key_value_name.into(),
2807 }
2808 }
2809 }
2810 pub mod get {
2811 use super::models;
2812 #[cfg(not(target_arch = "wasm32"))]
2813 use futures::future::BoxFuture;
2814 #[cfg(target_arch = "wasm32")]
2815 use futures::future::LocalBoxFuture as BoxFuture;
2816 #[derive(Debug)]
2817 pub struct Response(azure_core::Response);
2818 impl Response {
2819 pub async fn into_body(self) -> azure_core::Result<models::KeyValue> {
2820 let bytes = self.0.into_body().collect().await?;
2821 let body: models::KeyValue = serde_json::from_slice(&bytes)?;
2822 Ok(body)
2823 }
2824 pub fn into_raw_response(self) -> azure_core::Response {
2825 self.0
2826 }
2827 pub fn as_raw_response(&self) -> &azure_core::Response {
2828 &self.0
2829 }
2830 }
2831 impl From<Response> for azure_core::Response {
2832 fn from(rsp: Response) -> Self {
2833 rsp.into_raw_response()
2834 }
2835 }
2836 impl AsRef<azure_core::Response> for Response {
2837 fn as_ref(&self) -> &azure_core::Response {
2838 self.as_raw_response()
2839 }
2840 }
2841 #[derive(Clone)]
2842 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
2843 #[doc = r""]
2844 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
2845 #[doc = r" parameters can be chained."]
2846 #[doc = r""]
2847 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
2848 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
2849 #[doc = r" executes the request and returns a `Result` with the parsed"]
2850 #[doc = r" response."]
2851 #[doc = r""]
2852 #[doc = r" In order to execute the request without polling the service"]
2853 #[doc = r" until the operation completes, use `.send().await` instead."]
2854 #[doc = r""]
2855 #[doc = r" If you need lower-level access to the raw response details"]
2856 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
2857 #[doc = r" can finalize the request using the"]
2858 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
2859 #[doc = r" that resolves to a lower-level [`Response`] value."]
2860 pub struct RequestBuilder {
2861 pub(crate) client: super::super::Client,
2862 pub(crate) subscription_id: String,
2863 pub(crate) resource_group_name: String,
2864 pub(crate) config_store_name: String,
2865 pub(crate) key_value_name: String,
2866 }
2867 impl RequestBuilder {
2868 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
2869 #[doc = ""]
2870 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
2871 #[doc = "However, this function can provide more flexibility when required."]
2872 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
2873 Box::pin({
2874 let this = self.clone();
2875 async move {
2876 let url = this.url()?;
2877 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
2878 let bearer_token = this.client.bearer_token().await?;
2879 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
2880 let req_body = azure_core::EMPTY_BODY;
2881 req.set_body(req_body);
2882 Ok(Response(this.client.send(&mut req).await?))
2883 }
2884 })
2885 }
2886 fn url(&self) -> azure_core::Result<azure_core::Url> {
2887 let mut url = self.client.endpoint().clone();
2888 url.set_path(&format!(
2889 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/keyValues/{}",
2890 &self.subscription_id, &self.resource_group_name, &self.config_store_name, &self.key_value_name
2891 ));
2892 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
2893 if !has_api_version_already {
2894 url.query_pairs_mut()
2895 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
2896 }
2897 Ok(url)
2898 }
2899 }
2900 impl std::future::IntoFuture for RequestBuilder {
2901 type Output = azure_core::Result<models::KeyValue>;
2902 type IntoFuture = BoxFuture<'static, azure_core::Result<models::KeyValue>>;
2903 #[doc = "Returns a future that sends the request and returns the parsed response body."]
2904 #[doc = ""]
2905 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
2906 #[doc = ""]
2907 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
2908 fn into_future(self) -> Self::IntoFuture {
2909 Box::pin(async move { self.send().await?.into_body().await })
2910 }
2911 }
2912 }
2913 pub mod create_or_update {
2914 use super::models;
2915 #[cfg(not(target_arch = "wasm32"))]
2916 use futures::future::BoxFuture;
2917 #[cfg(target_arch = "wasm32")]
2918 use futures::future::LocalBoxFuture as BoxFuture;
2919 #[derive(Debug)]
2920 pub struct Response(azure_core::Response);
2921 impl Response {
2922 pub async fn into_body(self) -> azure_core::Result<models::KeyValue> {
2923 let bytes = self.0.into_body().collect().await?;
2924 let body: models::KeyValue = serde_json::from_slice(&bytes)?;
2925 Ok(body)
2926 }
2927 pub fn into_raw_response(self) -> azure_core::Response {
2928 self.0
2929 }
2930 pub fn as_raw_response(&self) -> &azure_core::Response {
2931 &self.0
2932 }
2933 }
2934 impl From<Response> for azure_core::Response {
2935 fn from(rsp: Response) -> Self {
2936 rsp.into_raw_response()
2937 }
2938 }
2939 impl AsRef<azure_core::Response> for Response {
2940 fn as_ref(&self) -> &azure_core::Response {
2941 self.as_raw_response()
2942 }
2943 }
2944 #[derive(Clone)]
2945 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
2946 #[doc = r""]
2947 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
2948 #[doc = r" parameters can be chained."]
2949 #[doc = r""]
2950 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
2951 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
2952 #[doc = r" executes the request and returns a `Result` with the parsed"]
2953 #[doc = r" response."]
2954 #[doc = r""]
2955 #[doc = r" In order to execute the request without polling the service"]
2956 #[doc = r" until the operation completes, use `.send().await` instead."]
2957 #[doc = r""]
2958 #[doc = r" If you need lower-level access to the raw response details"]
2959 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
2960 #[doc = r" can finalize the request using the"]
2961 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
2962 #[doc = r" that resolves to a lower-level [`Response`] value."]
2963 pub struct RequestBuilder {
2964 pub(crate) client: super::super::Client,
2965 pub(crate) subscription_id: String,
2966 pub(crate) resource_group_name: String,
2967 pub(crate) config_store_name: String,
2968 pub(crate) key_value_name: String,
2969 pub(crate) key_value_parameters: Option<models::KeyValue>,
2970 }
2971 impl RequestBuilder {
2972 #[doc = "The parameters for creating a key-value."]
2973 pub fn key_value_parameters(mut self, key_value_parameters: impl Into<models::KeyValue>) -> Self {
2974 self.key_value_parameters = Some(key_value_parameters.into());
2975 self
2976 }
2977 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
2978 #[doc = ""]
2979 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
2980 #[doc = "However, this function can provide more flexibility when required."]
2981 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
2982 Box::pin({
2983 let this = self.clone();
2984 async move {
2985 let url = this.url()?;
2986 let mut req = azure_core::Request::new(url, azure_core::Method::Put);
2987 let bearer_token = this.client.bearer_token().await?;
2988 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
2989 let req_body = if let Some(key_value_parameters) = &this.key_value_parameters {
2990 req.insert_header("content-type", "application/json");
2991 azure_core::to_json(key_value_parameters)?
2992 } else {
2993 azure_core::EMPTY_BODY
2994 };
2995 req.set_body(req_body);
2996 Ok(Response(this.client.send(&mut req).await?))
2997 }
2998 })
2999 }
3000 fn url(&self) -> azure_core::Result<azure_core::Url> {
3001 let mut url = self.client.endpoint().clone();
3002 url.set_path(&format!(
3003 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/keyValues/{}",
3004 &self.subscription_id, &self.resource_group_name, &self.config_store_name, &self.key_value_name
3005 ));
3006 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
3007 if !has_api_version_already {
3008 url.query_pairs_mut()
3009 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
3010 }
3011 Ok(url)
3012 }
3013 }
3014 impl std::future::IntoFuture for RequestBuilder {
3015 type Output = azure_core::Result<models::KeyValue>;
3016 type IntoFuture = BoxFuture<'static, azure_core::Result<models::KeyValue>>;
3017 #[doc = "Returns a future that sends the request and returns the parsed response body."]
3018 #[doc = ""]
3019 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
3020 #[doc = ""]
3021 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
3022 fn into_future(self) -> Self::IntoFuture {
3023 Box::pin(async move { self.send().await?.into_body().await })
3024 }
3025 }
3026 }
3027 pub mod delete {
3028 use super::models;
3029 #[cfg(not(target_arch = "wasm32"))]
3030 use futures::future::BoxFuture;
3031 #[cfg(target_arch = "wasm32")]
3032 use futures::future::LocalBoxFuture as BoxFuture;
3033 #[derive(Debug)]
3034 pub struct Response(azure_core::Response);
3035 impl Response {
3036 pub fn into_raw_response(self) -> azure_core::Response {
3037 self.0
3038 }
3039 pub fn as_raw_response(&self) -> &azure_core::Response {
3040 &self.0
3041 }
3042 }
3043 impl From<Response> for azure_core::Response {
3044 fn from(rsp: Response) -> Self {
3045 rsp.into_raw_response()
3046 }
3047 }
3048 impl AsRef<azure_core::Response> for Response {
3049 fn as_ref(&self) -> &azure_core::Response {
3050 self.as_raw_response()
3051 }
3052 }
3053 #[derive(Clone)]
3054 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
3055 #[doc = r""]
3056 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
3057 #[doc = r" parameters can be chained."]
3058 #[doc = r""]
3059 #[doc = r" This `RequestBuilder` implements a Long Running Operation"]
3060 #[doc = r" (LRO)."]
3061 #[doc = r""]
3062 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
3063 #[doc = r" which will convert the `RequestBuilder` into a future"]
3064 #[doc = r" executes the request and polls the service until the"]
3065 #[doc = r" operation completes."]
3066 #[doc = r""]
3067 #[doc = r" In order to execute the request without polling the service"]
3068 #[doc = r" until the operation completes, use"]
3069 #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"]
3070 #[doc = r" [`Response`] value."]
3071 pub struct RequestBuilder {
3072 pub(crate) client: super::super::Client,
3073 pub(crate) subscription_id: String,
3074 pub(crate) resource_group_name: String,
3075 pub(crate) config_store_name: String,
3076 pub(crate) key_value_name: String,
3077 }
3078 impl RequestBuilder {
3079 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
3080 #[doc = ""]
3081 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
3082 #[doc = "However, this function can provide more flexibility when required."]
3083 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
3084 Box::pin({
3085 let this = self.clone();
3086 async move {
3087 let url = this.url()?;
3088 let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
3089 let bearer_token = this.client.bearer_token().await?;
3090 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
3091 let req_body = azure_core::EMPTY_BODY;
3092 req.set_body(req_body);
3093 Ok(Response(this.client.send(&mut req).await?))
3094 }
3095 })
3096 }
3097 fn url(&self) -> azure_core::Result<azure_core::Url> {
3098 let mut url = self.client.endpoint().clone();
3099 url.set_path(&format!(
3100 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/keyValues/{}",
3101 &self.subscription_id, &self.resource_group_name, &self.config_store_name, &self.key_value_name
3102 ));
3103 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
3104 if !has_api_version_already {
3105 url.query_pairs_mut()
3106 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
3107 }
3108 Ok(url)
3109 }
3110 }
3111 }
3112}
3113pub mod replicas {
3114 use super::models;
3115 #[cfg(not(target_arch = "wasm32"))]
3116 use futures::future::BoxFuture;
3117 #[cfg(target_arch = "wasm32")]
3118 use futures::future::LocalBoxFuture as BoxFuture;
3119 pub struct Client(pub(crate) super::Client);
3120 impl Client {
3121 #[doc = "Lists the replicas for a given configuration store."]
3122 #[doc = ""]
3123 #[doc = "Arguments:"]
3124 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
3125 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
3126 #[doc = "* `config_store_name`: The name of the configuration store."]
3127 pub fn list_by_configuration_store(
3128 &self,
3129 subscription_id: impl Into<String>,
3130 resource_group_name: impl Into<String>,
3131 config_store_name: impl Into<String>,
3132 ) -> list_by_configuration_store::RequestBuilder {
3133 list_by_configuration_store::RequestBuilder {
3134 client: self.0.clone(),
3135 subscription_id: subscription_id.into(),
3136 resource_group_name: resource_group_name.into(),
3137 config_store_name: config_store_name.into(),
3138 skip_token: None,
3139 }
3140 }
3141 #[doc = "Gets the properties of the specified replica."]
3142 #[doc = ""]
3143 #[doc = "Arguments:"]
3144 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
3145 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
3146 #[doc = "* `config_store_name`: The name of the configuration store."]
3147 #[doc = "* `replica_name`: The name of the replica."]
3148 pub fn get(
3149 &self,
3150 subscription_id: impl Into<String>,
3151 resource_group_name: impl Into<String>,
3152 config_store_name: impl Into<String>,
3153 replica_name: impl Into<String>,
3154 ) -> get::RequestBuilder {
3155 get::RequestBuilder {
3156 client: self.0.clone(),
3157 subscription_id: subscription_id.into(),
3158 resource_group_name: resource_group_name.into(),
3159 config_store_name: config_store_name.into(),
3160 replica_name: replica_name.into(),
3161 }
3162 }
3163 #[doc = "Creates a replica with the specified parameters."]
3164 #[doc = ""]
3165 #[doc = "Arguments:"]
3166 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
3167 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
3168 #[doc = "* `config_store_name`: The name of the configuration store."]
3169 #[doc = "* `replica_name`: The name of the replica."]
3170 #[doc = "* `replica_creation_parameters`: The parameters for creating a replica."]
3171 pub fn create(
3172 &self,
3173 subscription_id: impl Into<String>,
3174 resource_group_name: impl Into<String>,
3175 config_store_name: impl Into<String>,
3176 replica_name: impl Into<String>,
3177 replica_creation_parameters: impl Into<models::Replica>,
3178 ) -> create::RequestBuilder {
3179 create::RequestBuilder {
3180 client: self.0.clone(),
3181 subscription_id: subscription_id.into(),
3182 resource_group_name: resource_group_name.into(),
3183 config_store_name: config_store_name.into(),
3184 replica_name: replica_name.into(),
3185 replica_creation_parameters: replica_creation_parameters.into(),
3186 }
3187 }
3188 #[doc = "Deletes a replica."]
3189 #[doc = ""]
3190 #[doc = "Arguments:"]
3191 #[doc = "* `subscription_id`: The Microsoft Azure subscription ID."]
3192 #[doc = "* `resource_group_name`: The name of the resource group to which the container registry belongs."]
3193 #[doc = "* `config_store_name`: The name of the configuration store."]
3194 #[doc = "* `replica_name`: The name of the replica."]
3195 pub fn delete(
3196 &self,
3197 subscription_id: impl Into<String>,
3198 resource_group_name: impl Into<String>,
3199 config_store_name: impl Into<String>,
3200 replica_name: impl Into<String>,
3201 ) -> delete::RequestBuilder {
3202 delete::RequestBuilder {
3203 client: self.0.clone(),
3204 subscription_id: subscription_id.into(),
3205 resource_group_name: resource_group_name.into(),
3206 config_store_name: config_store_name.into(),
3207 replica_name: replica_name.into(),
3208 }
3209 }
3210 }
3211 pub mod list_by_configuration_store {
3212 use super::models;
3213 #[cfg(not(target_arch = "wasm32"))]
3214 use futures::future::BoxFuture;
3215 #[cfg(target_arch = "wasm32")]
3216 use futures::future::LocalBoxFuture as BoxFuture;
3217 #[derive(Debug)]
3218 pub struct Response(azure_core::Response);
3219 impl Response {
3220 pub async fn into_body(self) -> azure_core::Result<models::ReplicaListResult> {
3221 let bytes = self.0.into_body().collect().await?;
3222 let body: models::ReplicaListResult = serde_json::from_slice(&bytes)?;
3223 Ok(body)
3224 }
3225 pub fn into_raw_response(self) -> azure_core::Response {
3226 self.0
3227 }
3228 pub fn as_raw_response(&self) -> &azure_core::Response {
3229 &self.0
3230 }
3231 }
3232 impl From<Response> for azure_core::Response {
3233 fn from(rsp: Response) -> Self {
3234 rsp.into_raw_response()
3235 }
3236 }
3237 impl AsRef<azure_core::Response> for Response {
3238 fn as_ref(&self) -> &azure_core::Response {
3239 self.as_raw_response()
3240 }
3241 }
3242 #[derive(Clone)]
3243 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
3244 #[doc = r""]
3245 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
3246 #[doc = r" parameters can be chained."]
3247 #[doc = r""]
3248 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
3249 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
3250 #[doc = r" executes the request and returns a `Result` with the parsed"]
3251 #[doc = r" response."]
3252 #[doc = r""]
3253 #[doc = r" In order to execute the request without polling the service"]
3254 #[doc = r" until the operation completes, use `.send().await` instead."]
3255 #[doc = r""]
3256 #[doc = r" If you need lower-level access to the raw response details"]
3257 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
3258 #[doc = r" can finalize the request using the"]
3259 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
3260 #[doc = r" that resolves to a lower-level [`Response`] value."]
3261 pub struct RequestBuilder {
3262 pub(crate) client: super::super::Client,
3263 pub(crate) subscription_id: String,
3264 pub(crate) resource_group_name: String,
3265 pub(crate) config_store_name: String,
3266 pub(crate) skip_token: Option<String>,
3267 }
3268 impl RequestBuilder {
3269 #[doc = "A skip token is used to continue retrieving items after an operation returns a partial result. If a previous response contains a nextLink element, the value of the nextLink element will include a skipToken parameter that specifies a starting point to use for subsequent calls."]
3270 pub fn skip_token(mut self, skip_token: impl Into<String>) -> Self {
3271 self.skip_token = Some(skip_token.into());
3272 self
3273 }
3274 pub fn into_stream(self) -> azure_core::Pageable<models::ReplicaListResult, azure_core::error::Error> {
3275 let make_request = move |continuation: Option<String>| {
3276 let this = self.clone();
3277 async move {
3278 let mut url = this.url()?;
3279 let rsp = match continuation {
3280 Some(value) => {
3281 url.set_path("");
3282 url = url.join(&value)?;
3283 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
3284 let bearer_token = this.client.bearer_token().await?;
3285 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
3286 let has_api_version_already =
3287 req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
3288 if !has_api_version_already {
3289 req.url_mut()
3290 .query_pairs_mut()
3291 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
3292 }
3293 let req_body = azure_core::EMPTY_BODY;
3294 req.set_body(req_body);
3295 this.client.send(&mut req).await?
3296 }
3297 None => {
3298 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
3299 let bearer_token = this.client.bearer_token().await?;
3300 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
3301 if let Some(skip_token) = &this.skip_token {
3302 req.url_mut().query_pairs_mut().append_pair("$skipToken", skip_token);
3303 }
3304 let req_body = azure_core::EMPTY_BODY;
3305 req.set_body(req_body);
3306 this.client.send(&mut req).await?
3307 }
3308 };
3309 let rsp = match rsp.status() {
3310 azure_core::StatusCode::Ok => Ok(Response(rsp)),
3311 status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
3312 status: status_code,
3313 error_code: None,
3314 })),
3315 };
3316 rsp?.into_body().await
3317 }
3318 };
3319 azure_core::Pageable::new(make_request)
3320 }
3321 fn url(&self) -> azure_core::Result<azure_core::Url> {
3322 let mut url = self.client.endpoint().clone();
3323 url.set_path(&format!(
3324 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/replicas",
3325 &self.subscription_id, &self.resource_group_name, &self.config_store_name
3326 ));
3327 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
3328 if !has_api_version_already {
3329 url.query_pairs_mut()
3330 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
3331 }
3332 Ok(url)
3333 }
3334 }
3335 }
3336 pub mod get {
3337 use super::models;
3338 #[cfg(not(target_arch = "wasm32"))]
3339 use futures::future::BoxFuture;
3340 #[cfg(target_arch = "wasm32")]
3341 use futures::future::LocalBoxFuture as BoxFuture;
3342 #[derive(Debug)]
3343 pub struct Response(azure_core::Response);
3344 impl Response {
3345 pub async fn into_body(self) -> azure_core::Result<models::Replica> {
3346 let bytes = self.0.into_body().collect().await?;
3347 let body: models::Replica = serde_json::from_slice(&bytes)?;
3348 Ok(body)
3349 }
3350 pub fn into_raw_response(self) -> azure_core::Response {
3351 self.0
3352 }
3353 pub fn as_raw_response(&self) -> &azure_core::Response {
3354 &self.0
3355 }
3356 }
3357 impl From<Response> for azure_core::Response {
3358 fn from(rsp: Response) -> Self {
3359 rsp.into_raw_response()
3360 }
3361 }
3362 impl AsRef<azure_core::Response> for Response {
3363 fn as_ref(&self) -> &azure_core::Response {
3364 self.as_raw_response()
3365 }
3366 }
3367 #[derive(Clone)]
3368 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
3369 #[doc = r""]
3370 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
3371 #[doc = r" parameters can be chained."]
3372 #[doc = r""]
3373 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
3374 #[doc = r" which will convert the [`RequestBuilder`] into a future"]
3375 #[doc = r" executes the request and returns a `Result` with the parsed"]
3376 #[doc = r" response."]
3377 #[doc = r""]
3378 #[doc = r" In order to execute the request without polling the service"]
3379 #[doc = r" until the operation completes, use `.send().await` instead."]
3380 #[doc = r""]
3381 #[doc = r" If you need lower-level access to the raw response details"]
3382 #[doc = r" (e.g. to inspect response headers or raw body data) then you"]
3383 #[doc = r" can finalize the request using the"]
3384 #[doc = r" [`RequestBuilder::send()`] method which returns a future"]
3385 #[doc = r" that resolves to a lower-level [`Response`] value."]
3386 pub struct RequestBuilder {
3387 pub(crate) client: super::super::Client,
3388 pub(crate) subscription_id: String,
3389 pub(crate) resource_group_name: String,
3390 pub(crate) config_store_name: String,
3391 pub(crate) replica_name: String,
3392 }
3393 impl RequestBuilder {
3394 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
3395 #[doc = ""]
3396 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
3397 #[doc = "However, this function can provide more flexibility when required."]
3398 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
3399 Box::pin({
3400 let this = self.clone();
3401 async move {
3402 let url = this.url()?;
3403 let mut req = azure_core::Request::new(url, azure_core::Method::Get);
3404 let bearer_token = this.client.bearer_token().await?;
3405 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
3406 let req_body = azure_core::EMPTY_BODY;
3407 req.set_body(req_body);
3408 Ok(Response(this.client.send(&mut req).await?))
3409 }
3410 })
3411 }
3412 fn url(&self) -> azure_core::Result<azure_core::Url> {
3413 let mut url = self.client.endpoint().clone();
3414 url.set_path(&format!(
3415 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/replicas/{}",
3416 &self.subscription_id, &self.resource_group_name, &self.config_store_name, &self.replica_name
3417 ));
3418 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
3419 if !has_api_version_already {
3420 url.query_pairs_mut()
3421 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
3422 }
3423 Ok(url)
3424 }
3425 }
3426 impl std::future::IntoFuture for RequestBuilder {
3427 type Output = azure_core::Result<models::Replica>;
3428 type IntoFuture = BoxFuture<'static, azure_core::Result<models::Replica>>;
3429 #[doc = "Returns a future that sends the request and returns the parsed response body."]
3430 #[doc = ""]
3431 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
3432 #[doc = ""]
3433 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
3434 fn into_future(self) -> Self::IntoFuture {
3435 Box::pin(async move { self.send().await?.into_body().await })
3436 }
3437 }
3438 }
3439 pub mod create {
3440 use super::models;
3441 #[cfg(not(target_arch = "wasm32"))]
3442 use futures::future::BoxFuture;
3443 #[cfg(target_arch = "wasm32")]
3444 use futures::future::LocalBoxFuture as BoxFuture;
3445 #[derive(Debug)]
3446 pub struct Response(azure_core::Response);
3447 impl Response {
3448 pub async fn into_body(self) -> azure_core::Result<models::Replica> {
3449 let bytes = self.0.into_body().collect().await?;
3450 let body: models::Replica = serde_json::from_slice(&bytes)?;
3451 Ok(body)
3452 }
3453 pub fn into_raw_response(self) -> azure_core::Response {
3454 self.0
3455 }
3456 pub fn as_raw_response(&self) -> &azure_core::Response {
3457 &self.0
3458 }
3459 }
3460 impl From<Response> for azure_core::Response {
3461 fn from(rsp: Response) -> Self {
3462 rsp.into_raw_response()
3463 }
3464 }
3465 impl AsRef<azure_core::Response> for Response {
3466 fn as_ref(&self) -> &azure_core::Response {
3467 self.as_raw_response()
3468 }
3469 }
3470 #[derive(Clone)]
3471 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
3472 #[doc = r""]
3473 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
3474 #[doc = r" parameters can be chained."]
3475 #[doc = r""]
3476 #[doc = r" This `RequestBuilder` implements a Long Running Operation"]
3477 #[doc = r" (LRO)."]
3478 #[doc = r""]
3479 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
3480 #[doc = r" which will convert the `RequestBuilder` into a future"]
3481 #[doc = r" executes the request and polls the service until the"]
3482 #[doc = r" operation completes."]
3483 #[doc = r""]
3484 #[doc = r" In order to execute the request without polling the service"]
3485 #[doc = r" until the operation completes, use"]
3486 #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"]
3487 #[doc = r" [`Response`] value."]
3488 pub struct RequestBuilder {
3489 pub(crate) client: super::super::Client,
3490 pub(crate) subscription_id: String,
3491 pub(crate) resource_group_name: String,
3492 pub(crate) config_store_name: String,
3493 pub(crate) replica_name: String,
3494 pub(crate) replica_creation_parameters: models::Replica,
3495 }
3496 impl RequestBuilder {
3497 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
3498 #[doc = ""]
3499 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
3500 #[doc = "However, this function can provide more flexibility when required."]
3501 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
3502 Box::pin({
3503 let this = self.clone();
3504 async move {
3505 let url = this.url()?;
3506 let mut req = azure_core::Request::new(url, azure_core::Method::Put);
3507 let bearer_token = this.client.bearer_token().await?;
3508 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
3509 req.insert_header("content-type", "application/json");
3510 let req_body = azure_core::to_json(&this.replica_creation_parameters)?;
3511 req.set_body(req_body);
3512 Ok(Response(this.client.send(&mut req).await?))
3513 }
3514 })
3515 }
3516 fn url(&self) -> azure_core::Result<azure_core::Url> {
3517 let mut url = self.client.endpoint().clone();
3518 url.set_path(&format!(
3519 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/replicas/{}",
3520 &self.subscription_id, &self.resource_group_name, &self.config_store_name, &self.replica_name
3521 ));
3522 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
3523 if !has_api_version_already {
3524 url.query_pairs_mut()
3525 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
3526 }
3527 Ok(url)
3528 }
3529 }
3530 impl std::future::IntoFuture for RequestBuilder {
3531 type Output = azure_core::Result<models::Replica>;
3532 type IntoFuture = BoxFuture<'static, azure_core::Result<models::Replica>>;
3533 #[doc = "Returns a future that polls the long running operation, returning once the operation completes."]
3534 #[doc = ""]
3535 #[doc = "To only submit the request but not monitor the status of the operation until completion, use `send()` instead."]
3536 #[doc = ""]
3537 #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
3538 #[doc = ""]
3539 #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
3540 fn into_future(self) -> Self::IntoFuture {
3541 Box::pin(async move {
3542 use azure_core::{
3543 error::{Error, ErrorKind},
3544 lro::{
3545 get_retry_after,
3546 location::{get_location, get_provisioning_state, FinalState},
3547 LroStatus,
3548 },
3549 sleep::sleep,
3550 };
3551 use std::time::Duration;
3552 let this = self.clone();
3553 let response = this.send().await?;
3554 let headers = response.as_raw_response().headers();
3555 let location = get_location(headers, FinalState::AzureAsyncOperation)?;
3556 if let Some(url) = location {
3557 loop {
3558 let mut req = azure_core::Request::new(url.clone(), azure_core::Method::Get);
3559 let bearer_token = self.client.bearer_token().await?;
3560 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
3561 let response = self.client.send(&mut req).await?;
3562 let headers = response.headers();
3563 let retry_after = get_retry_after(headers);
3564 let bytes = response.into_body().collect().await?;
3565 let provisioning_state = get_provisioning_state(&bytes).ok_or_else(|| {
3566 Error::message(
3567 ErrorKind::Other,
3568 "Long running operation failed (missing provisioning state)".to_string(),
3569 )
3570 })?;
3571 log::trace!("current provisioning_state: {provisioning_state:?}");
3572 match provisioning_state {
3573 LroStatus::Succeeded => {
3574 let mut req = azure_core::Request::new(self.url()?, azure_core::Method::Get);
3575 let bearer_token = self.client.bearer_token().await?;
3576 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
3577 let response = self.client.send(&mut req).await?;
3578 return Response(response).into_body().await;
3579 }
3580 LroStatus::Failed => {
3581 return Err(Error::message(ErrorKind::Other, "Long running operation failed".to_string()))
3582 }
3583 LroStatus::Canceled => {
3584 return Err(Error::message(ErrorKind::Other, "Long running operation canceled".to_string()))
3585 }
3586 _ => {
3587 sleep(retry_after).await;
3588 }
3589 }
3590 }
3591 } else {
3592 response.into_body().await
3593 }
3594 })
3595 }
3596 }
3597 }
3598 pub mod delete {
3599 use super::models;
3600 #[cfg(not(target_arch = "wasm32"))]
3601 use futures::future::BoxFuture;
3602 #[cfg(target_arch = "wasm32")]
3603 use futures::future::LocalBoxFuture as BoxFuture;
3604 #[derive(Debug)]
3605 pub struct Response(azure_core::Response);
3606 impl Response {
3607 pub fn into_raw_response(self) -> azure_core::Response {
3608 self.0
3609 }
3610 pub fn as_raw_response(&self) -> &azure_core::Response {
3611 &self.0
3612 }
3613 pub fn headers(&self) -> Headers {
3614 Headers(self.0.headers())
3615 }
3616 }
3617 impl From<Response> for azure_core::Response {
3618 fn from(rsp: Response) -> Self {
3619 rsp.into_raw_response()
3620 }
3621 }
3622 impl AsRef<azure_core::Response> for Response {
3623 fn as_ref(&self) -> &azure_core::Response {
3624 self.as_raw_response()
3625 }
3626 }
3627 pub struct Headers<'a>(&'a azure_core::headers::Headers);
3628 impl<'a> Headers<'a> {
3629 #[doc = "URL to query for status of the operation."]
3630 pub fn azure_async_operation(&self) -> azure_core::Result<&str> {
3631 self.0
3632 .get_str(&azure_core::headers::HeaderName::from_static("azure-asyncoperation"))
3633 }
3634 }
3635 #[derive(Clone)]
3636 #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
3637 #[doc = r""]
3638 #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
3639 #[doc = r" parameters can be chained."]
3640 #[doc = r""]
3641 #[doc = r" This `RequestBuilder` implements a Long Running Operation"]
3642 #[doc = r" (LRO)."]
3643 #[doc = r""]
3644 #[doc = r" To finalize and submit the request, invoke `.await`, which"]
3645 #[doc = r" which will convert the `RequestBuilder` into a future"]
3646 #[doc = r" executes the request and polls the service until the"]
3647 #[doc = r" operation completes."]
3648 #[doc = r""]
3649 #[doc = r" In order to execute the request without polling the service"]
3650 #[doc = r" until the operation completes, use"]
3651 #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"]
3652 #[doc = r" [`Response`] value."]
3653 pub struct RequestBuilder {
3654 pub(crate) client: super::super::Client,
3655 pub(crate) subscription_id: String,
3656 pub(crate) resource_group_name: String,
3657 pub(crate) config_store_name: String,
3658 pub(crate) replica_name: String,
3659 }
3660 impl RequestBuilder {
3661 #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
3662 #[doc = ""]
3663 #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
3664 #[doc = "However, this function can provide more flexibility when required."]
3665 pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
3666 Box::pin({
3667 let this = self.clone();
3668 async move {
3669 let url = this.url()?;
3670 let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
3671 let bearer_token = this.client.bearer_token().await?;
3672 req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
3673 let req_body = azure_core::EMPTY_BODY;
3674 req.set_body(req_body);
3675 Ok(Response(this.client.send(&mut req).await?))
3676 }
3677 })
3678 }
3679 fn url(&self) -> azure_core::Result<azure_core::Url> {
3680 let mut url = self.client.endpoint().clone();
3681 url.set_path(&format!(
3682 "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.AppConfiguration/configurationStores/{}/replicas/{}",
3683 &self.subscription_id, &self.resource_group_name, &self.config_store_name, &self.replica_name
3684 ));
3685 let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
3686 if !has_api_version_already {
3687 url.query_pairs_mut()
3688 .append_pair(azure_core::query_param::API_VERSION, "2023-03-01");
3689 }
3690 Ok(url)
3691 }
3692 }
3693 }
3694}