#![allow(unused_mut)]
#![allow(unused_variables)]
#![allow(unused_imports)]
#![allow(clippy::redundant_clone)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::module_inception)]
pub mod models;
#[derive(Clone)]
pub struct Client {
endpoint: azure_core::http::Url,
credential: crate::Credential,
scopes: Vec<String>,
pipeline: azure_core::http::Pipeline,
}
#[derive(Clone)]
pub struct ClientBuilder {
credential: crate::Credential,
endpoint: Option<azure_core::http::Url>,
scopes: Option<Vec<String>>,
options: azure_core::http::ClientOptions,
}
azure_core::static_url!(DEFAULT_ENDPOINT, "https://artifacts.dev.azure.com");
impl ClientBuilder {
#[doc = "Create a new instance of `ClientBuilder`."]
#[must_use]
pub fn new(credential: crate::Credential) -> Self {
Self {
credential,
endpoint: None,
scopes: None,
options: azure_core::http::ClientOptions::default(),
}
}
#[doc = "Set the endpoint."]
#[must_use]
pub fn endpoint(mut self, endpoint: impl Into<azure_core::http::Url>) -> Self {
self.endpoint = Some(endpoint.into());
self
}
#[doc = "Set the scopes."]
#[must_use]
pub fn scopes(mut self, scopes: &[&str]) -> Self {
self.scopes = Some(scopes.iter().map(|scope| (*scope).to_owned()).collect());
self
}
#[doc = "Set the retry options."]
#[must_use]
pub fn retry(mut self, retry: impl Into<azure_core::http::RetryOptions>) -> Self {
self.options.retry = retry.into();
self
}
#[doc = "Set the transport options."]
#[must_use]
pub fn transport(mut self, transport: impl Into<azure_core::http::Transport>) -> Self {
self.options.transport = Some(transport.into());
self
}
#[doc = "Set per-call policies."]
#[must_use]
pub fn per_call_policies(
mut self,
policies: impl Into<Vec<std::sync::Arc<dyn azure_core::http::policies::Policy>>>,
) -> Self {
self.options.per_call_policies = policies.into();
self
}
#[doc = "Set per-try policies."]
#[must_use]
pub fn per_try_policies(
mut self,
policies: impl Into<Vec<std::sync::Arc<dyn azure_core::http::policies::Policy>>>,
) -> Self {
self.options.per_try_policies = policies.into();
self
}
#[doc = "Convert the builder into a `Client` instance."]
pub fn build(self) -> Client {
let endpoint = self.endpoint.unwrap_or_else(|| DEFAULT_ENDPOINT.to_owned());
let scopes = self
.scopes
.unwrap_or_else(|| vec![crate::ADO_SCOPE.to_string()]);
Client::new(endpoint, self.credential, scopes, self.options)
}
}
impl Client {
pub(crate) fn endpoint(&self) -> &azure_core::http::Url {
&self.endpoint
}
pub(crate) fn token_credential(&self) -> &crate::Credential {
&self.credential
}
pub(crate) fn scopes(&self) -> Vec<&str> {
self.scopes.iter().map(String::as_str).collect()
}
pub(crate) async fn send(
&self,
request: &mut azure_core::http::Request,
) -> azure_core::Result<azure_core::http::RawResponse> {
let context = azure_core::http::Context::default();
self.pipeline.send(&context, request, None).await
}
#[doc = "Create a new `ClientBuilder`."]
#[must_use]
pub fn builder(credential: crate::Credential) -> ClientBuilder {
ClientBuilder::new(credential)
}
#[doc = "Create a new `Client`."]
#[must_use]
pub fn new(
endpoint: impl Into<azure_core::http::Url>,
credential: crate::Credential,
scopes: Vec<String>,
options: azure_core::http::ClientOptions,
) -> Self {
let endpoint = endpoint.into();
let pipeline = azure_core::http::Pipeline::new(
option_env!("CARGO_PKG_NAME"),
option_env!("CARGO_PKG_VERSION"),
options,
Vec::new(),
Vec::new(),
None,
);
Self {
endpoint,
credential,
scopes,
pipeline,
}
}
pub fn availability_client(&self) -> availability::Client {
availability::Client(self.clone())
}
pub fn client_client(&self) -> client::Client {
client::Client(self.clone())
}
pub fn contents_client(&self) -> contents::Client {
contents::Client(self.clone())
}
pub fn requests_client(&self) -> requests::Client {
requests::Client(self.clone())
}
pub fn symsrv_client(&self) -> symsrv::Client {
symsrv::Client(self.clone())
}
}
pub mod requests {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Create debug entries for a symbol request as specified by its name."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `body`: A batch that contains debug entries to create."]
#[doc = "* `request_name`: The symbol request name."]
#[doc = "* `collection`: A valid debug entry collection name. Must be \"debugentries\"."]
pub fn create_requests_request_name_debug_entries(
&self,
organization: impl Into<String>,
body: impl Into<models::DebugEntryCreateBatch>,
request_name: impl Into<String>,
collection: impl Into<String>,
) -> create_requests_request_name_debug_entries::RequestBuilder {
create_requests_request_name_debug_entries::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
request_name: request_name.into(),
collection: collection.into(),
}
}
#[doc = "Get a symbol request by request name."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `request_name`: The symbol request name."]
pub fn get_requests_request_name(
&self,
organization: impl Into<String>,
request_name: impl Into<String>,
) -> get_requests_request_name::RequestBuilder {
get_requests_request_name::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
request_name: request_name.into(),
}
}
#[doc = "Create a new symbol request."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `body`: The symbol request to create."]
pub fn create_requests(
&self,
organization: impl Into<String>,
body: impl Into<models::Request>,
) -> create_requests::RequestBuilder {
create_requests::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
}
}
#[doc = "Update a symbol request by request name."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `body`: The symbol request."]
#[doc = "* `request_name`: The symbol request name."]
pub fn update_requests_request_name(
&self,
organization: impl Into<String>,
body: impl Into<models::Request>,
request_name: impl Into<String>,
) -> update_requests_request_name::RequestBuilder {
update_requests_request_name::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
request_name: request_name.into(),
}
}
#[doc = "Delete a symbol request by request name."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `request_name`: The symbol request name."]
pub fn delete_requests_request_name(
&self,
organization: impl Into<String>,
request_name: impl Into<String>,
) -> delete_requests_request_name::RequestBuilder {
delete_requests_request_name::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
request_name: request_name.into(),
synchronous: None,
}
}
#[doc = "Get a symbol request by request identifier."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `request_id`: The symbol request identifier."]
pub fn get_requests_request_id(
&self,
organization: impl Into<String>,
request_id: impl Into<String>,
) -> get_requests_request_id::RequestBuilder {
get_requests_request_id::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
request_id: request_id.into(),
}
}
#[doc = "Create debug entries for a symbol request as specified by its identifier."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `body`: A batch that contains debug entries to create."]
#[doc = "* `request_id`: The symbol request identifier."]
#[doc = "* `collection`: A valid debug entry collection name. Must be \"debugentries\"."]
pub fn create_requests_request_id_debug_entries(
&self,
organization: impl Into<String>,
body: impl Into<models::DebugEntryCreateBatch>,
request_id: impl Into<String>,
collection: impl Into<String>,
) -> create_requests_request_id_debug_entries::RequestBuilder {
create_requests_request_id_debug_entries::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
request_id: request_id.into(),
collection: collection.into(),
}
}
#[doc = "Update a symbol request by request identifier."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `body`: The symbol request."]
#[doc = "* `request_id`: The symbol request identifier."]
pub fn update_requests_request_id(
&self,
organization: impl Into<String>,
body: impl Into<models::Request>,
request_id: impl Into<String>,
) -> update_requests_request_id::RequestBuilder {
update_requests_request_id::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
body: body.into(),
request_id: request_id.into(),
}
}
#[doc = "Delete a symbol request by request identifier."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `request_id`: The symbol request identifier."]
pub fn delete_requests_request_id(
&self,
organization: impl Into<String>,
request_id: impl Into<String>,
) -> delete_requests_request_id::RequestBuilder {
delete_requests_request_id::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
request_id: request_id.into(),
synchronous: None,
}
}
}
pub mod create_requests_request_name_debug_entries {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::DebugEntryList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::DebugEntryList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::DebugEntryCreateBatch,
pub(crate) request_name: String,
pub(crate) collection: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
let request_name = &this.request_name;
req.url_mut()
.query_pairs_mut()
.append_pair("requestName", request_name);
let collection = &this.collection;
req.url_mut()
.query_pairs_mut()
.append_pair("collection", collection);
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/requests?requestName={}&collection={}",
self.client.endpoint(),
&self.organization,
&self.request_name,
&self.collection
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::DebugEntryList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::DebugEntryList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod get_requests_request_name {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::Request, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::Request> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) request_name: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let request_name = &this.request_name;
req.url_mut()
.query_pairs_mut()
.append_pair("requestName", request_name);
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/requests",
self.client.endpoint(),
&self.organization
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::Request>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::Request>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod create_requests {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::Request, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::Request> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::Request,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/requests",
self.client.endpoint(),
&self.organization
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::Request>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::Request>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod update_requests_request_name {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::Request, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::Request> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::Request,
pub(crate) request_name: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Patch);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
let request_name = &this.request_name;
req.url_mut()
.query_pairs_mut()
.append_pair("requestName", request_name);
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/requests",
self.client.endpoint(),
&self.organization
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::Request>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::Request>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod delete_requests_request_name {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) request_name: String,
pub(crate) synchronous: Option<bool>,
}
impl RequestBuilder {
#[doc = "If true, delete all the debug entries under this request synchronously in the current session. If false, the deletion will be postponed to a later point and be executed automatically by the system."]
pub fn synchronous(mut self, synchronous: bool) -> Self {
self.synchronous = Some(synchronous);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Delete);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let request_name = &this.request_name;
req.url_mut()
.query_pairs_mut()
.append_pair("requestName", request_name);
if let Some(synchronous) = &this.synchronous {
req.url_mut()
.query_pairs_mut()
.append_pair("synchronous", &synchronous.to_string());
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/requests",
self.client.endpoint(),
&self.organization
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
pub mod get_requests_request_id {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::Request, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::Request> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) request_id: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/requests/{}",
self.client.endpoint(),
&self.organization,
&self.request_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::Request>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::Request>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod create_requests_request_id_debug_entries {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::DebugEntryList, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::DebugEntryList> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::DebugEntryCreateBatch,
pub(crate) request_id: String,
pub(crate) collection: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Post);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
let collection = &this.collection;
req.url_mut()
.query_pairs_mut()
.append_pair("collection", collection);
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/requests/{}",
self.client.endpoint(),
&self.organization,
&self.request_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::DebugEntryList>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::DebugEntryList>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod update_requests_request_id {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(
azure_core::http::Response<models::Request, azure_core::http::JsonFormat>,
);
impl Response {
pub fn into_body(self) -> azure_core::Result<models::Request> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) body: models::Request,
pub(crate) request_id: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Patch);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::json::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/requests/{}",
self.client.endpoint(),
&self.organization,
&self.request_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::Request>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::Request>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
pub mod delete_requests_request_id {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) request_id: String,
pub(crate) synchronous: Option<bool>,
}
impl RequestBuilder {
#[doc = "If true, delete all the debug entries under this request synchronously in the current session. If false, the deletion will be postponed to a later point and be executed automatically by the system."]
pub fn synchronous(mut self, synchronous: bool) -> Self {
self.synchronous = Some(synchronous);
self
}
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Delete);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
if let Some(synchronous) = &this.synchronous {
req.url_mut()
.query_pairs_mut()
.append_pair("synchronous", &synchronous.to_string());
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/requests/{}",
self.client.endpoint(),
&self.organization,
&self.request_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
}
pub mod availability {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Check the availability of symbol service. This includes checking for feature flag, and possibly license in future. Note this is NOT an anonymous endpoint, and the caller will be redirected to authentication before hitting it."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
pub fn check_availability(
&self,
organization: impl Into<String>,
) -> check_availability::RequestBuilder {
check_availability::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
}
}
}
pub mod check_availability {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/availability",
self.client.endpoint(),
&self.organization
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
}
pub mod client {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get client version information."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
pub fn head_client(&self, organization: impl Into<String>) -> head_client::RequestBuilder {
head_client::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
}
}
#[doc = "Get the client package."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `client_type`: Either \"EXE\" for a zip file containing a Windows symbol client (a.k.a. symbol.exe) along with dependencies, or \"TASK\" for a VSTS task that can be run on a VSTS build agent. All the other values are invalid. The parameter is case-insensitive."]
pub fn get(
&self,
organization: impl Into<String>,
client_type: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
client_type: client_type.into(),
}
}
}
pub mod head_client {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Head);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/client",
self.client.endpoint(),
&self.organization
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<String, azure_core::http::JsonFormat>);
impl Response {
pub fn into_body(self) -> azure_core::Result<String> {
self.0.into_model()
}
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) client_type: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/client/{}",
self.client.endpoint(),
&self.organization,
&self.client_type
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<String>;
type IntoFuture = BoxFuture<'static, azure_core::Result<String>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body() })
}
}
}
}
pub mod contents {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get a stitched debug entry for a symbol request as specified by symbol request identifier and debug entry identifier."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `request_id`: The symbol request identifier."]
#[doc = "* `debug_entry_id`: The debug entry identifier."]
pub fn get(
&self,
organization: impl Into<String>,
request_id: impl Into<String>,
debug_entry_id: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
request_id: request_id.into(),
debug_entry_id: debug_entry_id.into(),
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) request_id: String,
pub(crate) debug_entry_id: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/requests/{}/contents/{}",
self.client.endpoint(),
&self.organization,
&self.request_id,
&self.debug_entry_id
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
}
pub mod symsrv {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Given a client key, returns the best matched debug entry."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `organization`: The name of the Azure DevOps organization."]
#[doc = "* `debug_entry_client_key`: A \"client key\" used by both ends of Microsoft's symbol protocol to identify a debug entry. The semantics of client key is governed by symsrv and is beyond the scope of this documentation."]
pub fn get(
&self,
organization: impl Into<String>,
debug_entry_client_key: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
organization: organization.into(),
debug_entry_client_key: debug_entry_client_key.into(),
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::http::Response<(), azure_core::http::NoFormat>);
impl Response {
pub fn into_raw_response(self) -> azure_core::http::RawResponse {
self.0.into()
}
}
#[derive(Clone)]
#[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."]
#[doc = r""]
#[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"]
#[doc = r" parameters can be chained."]
#[doc = r""]
#[doc = r" To finalize and submit the request, invoke `.await`, which"]
#[doc = r" converts the [`RequestBuilder`] into a future,"]
#[doc = r" executes the request and returns a `Result` with the parsed"]
#[doc = r" response."]
#[doc = r""]
#[doc = r" If you need lower-level access to the raw response details"]
#[doc = r" (e.g. to inspect response headers or raw body data) then you"]
#[doc = r" can finalize the request using the"]
#[doc = r" [`RequestBuilder::send()`] method which returns a future"]
#[doc = r" that resolves to a lower-level [`Response`] value."]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) organization: String,
pub(crate) debug_entry_client_key: String,
}
impl RequestBuilder {
#[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."]
#[doc = ""]
#[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."]
#[doc = "However, this function can provide more flexibility when required."]
pub fn send(self) -> BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = this.url()?;
let mut req =
azure_core::http::Request::new(url, azure_core::http::Method::Get);
if let Some(auth_header) = this
.client
.token_credential()
.http_authorization_header(&this.client.scopes())
.await?
{
req.insert_header(
azure_core::http::headers::AUTHORIZATION,
auth_header,
);
}
let req_body = azure_core::Bytes::new();
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?.into()))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::http::Url> {
let mut url = azure_core::http::Url::parse(&format!(
"{}/{}/_apis/symbol/symsrv/{}",
self.client.endpoint(),
&self.organization,
&self.debug_entry_client_key
))?;
let has_api_version_already = url.query_pairs().any(|(k, _)| k == "api-version");
if !has_api_version_already {
url.query_pairs_mut()
.append_pair("api-version", "7.1-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<()>;
type IntoFuture = BoxFuture<'static, azure_core::Result<()>>;
#[doc = "Returns a future that sends the request and waits for the response."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move {
let _rsp = self.send().await?;
Ok(())
})
}
}
}
}