#![allow(unused_mut)]
#![allow(unused_variables)]
#![allow(unused_imports)]
#![allow(clippy::redundant_clone)]
pub mod models;
#[derive(Clone)]
pub struct Client {
endpoint: String,
credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
scopes: Vec<String>,
pipeline: azure_core::Pipeline,
}
#[derive(Clone)]
pub struct ClientBuilder {
credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
endpoint: Option<String>,
scopes: Option<Vec<String>>,
options: azure_core::ClientOptions,
}
pub const DEFAULT_ENDPOINT: &str = azure_core::resource_manager_endpoint::AZURE_PUBLIC_CLOUD;
impl ClientBuilder {
#[doc = "Create a new instance of `ClientBuilder`."]
#[must_use]
pub fn new(credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>) -> Self {
Self {
credential,
endpoint: None,
scopes: None,
options: azure_core::ClientOptions::default(),
}
}
#[doc = "Set the endpoint."]
#[must_use]
pub fn endpoint(mut self, endpoint: impl Into<String>) -> 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::RetryOptions>) -> Self {
self.options = self.options.retry(retry);
self
}
#[doc = "Set the transport options."]
#[must_use]
pub fn transport(mut self, transport: impl Into<azure_core::TransportOptions>) -> Self {
self.options = self.options.transport(transport);
self
}
#[doc = "Convert the builder into a `Client` instance."]
#[must_use]
pub fn build(self) -> Client {
let endpoint = self.endpoint.unwrap_or_else(|| DEFAULT_ENDPOINT.to_owned());
let scopes = self.scopes.unwrap_or_else(|| vec![format!("{}/", endpoint)]);
Client::new(endpoint, self.credential, scopes, self.options)
}
}
impl Client {
pub(crate) fn endpoint(&self) -> &str {
self.endpoint.as_str()
}
pub(crate) fn token_credential(&self) -> &dyn azure_core::auth::TokenCredential {
self.credential.as_ref()
}
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::Request) -> azure_core::Result<azure_core::Response> {
let mut context = azure_core::Context::default();
self.pipeline.send(&mut context, request).await
}
#[doc = "Create a new `ClientBuilder`."]
#[must_use]
pub fn builder(credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>) -> ClientBuilder {
ClientBuilder::new(credential)
}
#[doc = "Create a new `Client`."]
#[must_use]
pub fn new(
endpoint: impl Into<String>,
credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
scopes: Vec<String>,
options: azure_core::ClientOptions,
) -> Self {
let endpoint = endpoint.into();
let pipeline = azure_core::Pipeline::new(
option_env!("CARGO_PKG_NAME"),
option_env!("CARGO_PKG_VERSION"),
options,
Vec::new(),
Vec::new(),
);
Self {
endpoint,
credential,
scopes,
pipeline,
}
}
pub fn address_client(&self) -> address::Client {
address::Client(self.clone())
}
pub fn agreements_client(&self) -> agreements::Client {
agreements::Client(self.clone())
}
pub fn available_balances_client(&self) -> available_balances::Client {
available_balances::Client(self.clone())
}
pub fn billing_accounts_client(&self) -> billing_accounts::Client {
billing_accounts::Client(self.clone())
}
pub fn billing_permissions_client(&self) -> billing_permissions::Client {
billing_permissions::Client(self.clone())
}
pub fn billing_profiles_client(&self) -> billing_profiles::Client {
billing_profiles::Client(self.clone())
}
pub fn billing_property_client(&self) -> billing_property::Client {
billing_property::Client(self.clone())
}
pub fn billing_role_assignments_client(&self) -> billing_role_assignments::Client {
billing_role_assignments::Client(self.clone())
}
pub fn billing_role_definitions_client(&self) -> billing_role_definitions::Client {
billing_role_definitions::Client(self.clone())
}
pub fn billing_subscriptions_client(&self) -> billing_subscriptions::Client {
billing_subscriptions::Client(self.clone())
}
pub fn customers_client(&self) -> customers::Client {
customers::Client(self.clone())
}
pub fn departments_client(&self) -> departments::Client {
departments::Client(self.clone())
}
pub fn enrollment_account_role_assignments_client(&self) -> enrollment_account_role_assignments::Client {
enrollment_account_role_assignments::Client(self.clone())
}
pub fn enrollment_accounts_client(&self) -> enrollment_accounts::Client {
enrollment_accounts::Client(self.clone())
}
pub fn enrollment_department_role_assignments_client(&self) -> enrollment_department_role_assignments::Client {
enrollment_department_role_assignments::Client(self.clone())
}
pub fn instructions_client(&self) -> instructions::Client {
instructions::Client(self.clone())
}
pub fn invoice_sections_client(&self) -> invoice_sections::Client {
invoice_sections::Client(self.clone())
}
pub fn invoices_client(&self) -> invoices::Client {
invoices::Client(self.clone())
}
pub fn operations_client(&self) -> operations::Client {
operations::Client(self.clone())
}
pub fn partner_transfers_client(&self) -> partner_transfers::Client {
partner_transfers::Client(self.clone())
}
pub fn payment_methods_client(&self) -> payment_methods::Client {
payment_methods::Client(self.clone())
}
pub fn policies_client(&self) -> policies::Client {
policies::Client(self.clone())
}
pub fn price_sheet_client(&self) -> price_sheet::Client {
price_sheet::Client(self.clone())
}
pub fn products_client(&self) -> products::Client {
products::Client(self.clone())
}
pub fn recipient_transfers_client(&self) -> recipient_transfers::Client {
recipient_transfers::Client(self.clone())
}
pub fn role_assignments_client(&self) -> role_assignments::Client {
role_assignments::Client(self.clone())
}
pub fn transactions_client(&self) -> transactions::Client {
transactions::Client(self.clone())
}
pub fn transfers_client(&self) -> transfers::Client {
transfers::Client(self.clone())
}
}
pub mod billing_accounts {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the billing accounts that a user has access to."]
pub fn list(&self) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
expand: None,
}
}
#[doc = "Gets a billing account by its ID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn get(&self, billing_account_name: impl Into<String>) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
expand: None,
}
}
#[doc = "Updates the properties of a billing account. Currently, displayName and address can be updated. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `parameters`: Request parameters that are provided to the update billing account operation."]
pub fn update(
&self,
billing_account_name: impl Into<String>,
parameters: impl Into<models::BillingAccountUpdateRequest>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Lists the invoice sections for which the user has permission to create Azure subscriptions. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn list_invoice_sections_by_create_subscription_permission(
&self,
billing_account_name: impl Into<String>,
) -> list_invoice_sections_by_create_subscription_permission::RequestBuilder {
list_invoice_sections_by_create_subscription_permission::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingAccountListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingAccountListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) expand: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to expand the address, invoice sections and billing profiles."]
pub fn expand(mut self, expand: impl Into<String>) -> Self {
self.expand = Some(expand.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url =
azure_core::Url::parse(&format!("{}/providers/Microsoft.Billing/billingAccounts", this.client.endpoint(),))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(expand) = &this.expand {
req.url_mut().query_pairs_mut().append_pair("$expand", expand);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingAccountListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingAccount> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingAccount = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) expand: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to expand the address, invoice sections and billing profiles."]
pub fn expand(mut self, expand: impl Into<String>) -> Self {
self.expand = Some(expand.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}",
this.client.endpoint(),
&this.billing_account_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(expand) = &this.expand {
req.url_mut().query_pairs_mut().append_pair("$expand", expand);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingAccount>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingAccount> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingAccount = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) parameters: models::BillingAccountUpdateRequest,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}",
this.client.endpoint(),
&this.billing_account_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingAccount>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_invoice_sections_by_create_subscription_permission {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::InvoiceSectionListWithCreateSubPermissionResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::InvoiceSectionListWithCreateSubPermissionResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
}
impl RequestBuilder {
pub fn into_stream(
self,
) -> azure_core::Pageable<models::InvoiceSectionListWithCreateSubPermissionResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/listInvoiceSectionsWithCreateSubscriptionPermission",
this.client.endpoint(),
&this.billing_account_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod payment_methods {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the payment Methods for a billing account. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn list_by_billing_account(&self, billing_account_name: impl Into<String>) -> list_by_billing_account::RequestBuilder {
list_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
}
}
#[doc = "Lists the payment Methods for a billing profile. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn list_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
) -> list_by_billing_profile::RequestBuilder {
list_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
}
}
}
pub mod list_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PaymentMethodsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::PaymentMethodsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::PaymentMethodsListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/paymentMethods",
this.client.endpoint(),
&this.billing_account_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PaymentMethodsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::PaymentMethodsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::PaymentMethodsListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/paymentMethods",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod address {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Validates an address. Use the operation to validate an address before using it as a billing account or a billing profile address."]
pub fn validate(&self, address: impl Into<models::AddressDetails>) -> validate::RequestBuilder {
validate::RequestBuilder {
client: self.0.clone(),
address: address.into(),
}
}
}
pub mod validate {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ValidateAddressResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::ValidateAddressResponse = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) address: models::AddressDetails,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url =
azure_core::Url::parse(&format!("{}/providers/Microsoft.Billing/validateAddress", this.client.endpoint(),))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.address)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ValidateAddressResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod available_balances {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "The available credit balance for a billing profile. This is the balance that can be used for pay now to settle due or past due invoices. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn get_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
) -> get_by_billing_profile::RequestBuilder {
get_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
}
}
}
pub mod get_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AvailableBalance> {
let bytes = self.0.into_body().collect().await?;
let body: models::AvailableBalance = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/availableBalance/default",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AvailableBalance>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod instructions {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the instructions by billing profile id."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn list_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
) -> list_by_billing_profile::RequestBuilder {
list_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
}
}
#[doc = "Get the instruction by name. These are custom billing instructions and are only applicable for certain customers."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `instruction_name`: Instruction Name."]
pub fn get(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
instruction_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
instruction_name: instruction_name.into(),
}
}
#[doc = "Creates or updates an instruction. These are custom billing instructions and are only applicable for certain customers."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `instruction_name`: Instruction Name."]
#[doc = "* `parameters`: The new instruction."]
pub fn put(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
instruction_name: impl Into<String>,
parameters: impl Into<models::Instruction>,
) -> put::RequestBuilder {
put::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
instruction_name: instruction_name.into(),
parameters: parameters.into(),
}
}
}
pub mod list_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::InstructionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::InstructionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::InstructionListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/instructions",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Instruction> {
let bytes = self.0.into_body().collect().await?;
let body: models::Instruction = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) instruction_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/instructions/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.instruction_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Instruction>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod put {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Instruction> {
let bytes = self.0.into_body().collect().await?;
let body: models::Instruction = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) instruction_name: String,
pub(crate) parameters: models::Instruction,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/instructions/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.instruction_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Instruction>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod billing_profiles {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Validates if the default payment method can be detached from the billing profile. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn get_eligibility_to_detach_payment_method(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
) -> get_eligibility_to_detach_payment_method::RequestBuilder {
get_eligibility_to_detach_payment_method::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
}
}
#[doc = "Lists the billing profiles that a user has access to. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement or Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn list_by_billing_account(&self, billing_account_name: impl Into<String>) -> list_by_billing_account::RequestBuilder {
list_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
expand: None,
}
}
#[doc = "Gets a billing profile by its ID. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement or Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn get(&self, billing_account_name: impl Into<String>, billing_profile_name: impl Into<String>) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
expand: None,
}
}
#[doc = "Creates a billing profile. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement or Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `parameters`: Request parameters that are provided to the create billing profile operation."]
pub fn create(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
parameters: impl Into<models::BillingProfileCreationRequest>,
) -> create::RequestBuilder {
create::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Updates the properties of a billing profile. Currently, displayName, poNumber, bill-to address and invoiceEmailOptIn can be updated. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement or Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `parameters`: Request parameters supplied to the update billing profile operation."]
pub fn update(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
parameters: impl Into<models::BillingProfile>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
parameters: parameters.into(),
}
}
}
pub mod get_eligibility_to_detach_payment_method {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DetachPaymentMethodEligibilityResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::DetachPaymentMethodEligibilityResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/validateDetachPaymentMethodEligibility",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::DetachPaymentMethodEligibilityResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingProfileListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingProfileListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) expand: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to expand the invoice sections."]
pub fn expand(mut self, expand: impl Into<String>) -> Self {
self.expand = Some(expand.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles",
this.client.endpoint(),
&this.billing_account_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(expand) = &this.expand {
req.url_mut().query_pairs_mut().append_pair("$expand", expand);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingProfileListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingProfile> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingProfile = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) expand: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to expand the invoice sections."]
pub fn expand(mut self, expand: impl Into<String>) -> Self {
self.expand = Some(expand.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(expand) = &this.expand {
req.url_mut().query_pairs_mut().append_pair("$expand", expand);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingProfile>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingProfile> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingProfile = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
pub fn headers(&self) -> Headers {
Headers(self.0.headers())
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
pub struct Headers<'a>(&'a azure_core::headers::Headers);
impl<'a> Headers<'a> {
#[doc = "Location URI to poll for result"]
pub fn location(&self) -> azure_core::Result<&str> {
self.0.get_str(&azure_core::headers::HeaderName::from_static("location"))
}
#[doc = "Recommended time to wait before making another request to check the status of the operation. The time is specified in seconds."]
pub fn retry_after(&self) -> azure_core::Result<i32> {
self.0.get_as(&azure_core::headers::HeaderName::from_static("retry-after"))
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) parameters: models::BillingProfileCreationRequest,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingProfile>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingProfile> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingProfile = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
pub fn headers(&self) -> Headers {
Headers(self.0.headers())
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
pub struct Headers<'a>(&'a azure_core::headers::Headers);
impl<'a> Headers<'a> {
#[doc = "GET this URL to retrieve the status of the asynchronous operation."]
pub fn location(&self) -> azure_core::Result<&str> {
self.0.get_str(&azure_core::headers::HeaderName::from_static("location"))
}
#[doc = "The amount of delay to use while the status of the operation is checked. The value is expressed in seconds."]
pub fn retry_after(&self) -> azure_core::Result<&str> {
self.0.get_str(&azure_core::headers::HeaderName::from_static("retry-after"))
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) parameters: models::BillingProfile,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingProfile>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod customers {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the customers that are billed to a billing profile. The operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn list_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
) -> list_by_billing_profile::RequestBuilder {
list_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
filter: None,
skiptoken: None,
}
}
#[doc = "Lists the customers that are billed to a billing account. The operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn list_by_billing_account(&self, billing_account_name: impl Into<String>) -> list_by_billing_account::RequestBuilder {
list_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
filter: None,
skiptoken: None,
}
}
#[doc = "Gets a customer by its ID. The operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
pub fn get(&self, billing_account_name: impl Into<String>, customer_name: impl Into<String>) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
customer_name: customer_name.into(),
expand: None,
}
}
}
pub mod list_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CustomerListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::CustomerListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) filter: Option<String>,
pub(crate) skiptoken: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to filter the list of customers."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "Skiptoken is only used if a previous operation returned 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."]
pub fn skiptoken(mut self, skiptoken: impl Into<String>) -> Self {
self.skiptoken = Some(skiptoken.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::CustomerListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/customers",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(skiptoken) = &this.skiptoken {
req.url_mut().query_pairs_mut().append_pair("$skiptoken", skiptoken);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CustomerListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::CustomerListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) filter: Option<String>,
pub(crate) skiptoken: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to filter the list of customers."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "Skiptoken is only used if a previous operation returned 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."]
pub fn skiptoken(mut self, skiptoken: impl Into<String>) -> Self {
self.skiptoken = Some(skiptoken.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::CustomerListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/customers",
this.client.endpoint(),
&this.billing_account_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(skiptoken) = &this.skiptoken {
req.url_mut().query_pairs_mut().append_pair("$skiptoken", skiptoken);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Customer> {
let bytes = self.0.into_body().collect().await?;
let body: models::Customer = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) customer_name: String,
pub(crate) expand: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to expand enabledAzurePlans and resellers"]
pub fn expand(mut self, expand: impl Into<String>) -> Self {
self.expand = Some(expand.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/customers/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.customer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(expand) = &this.expand {
req.url_mut().query_pairs_mut().append_pair("$expand", expand);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Customer>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod invoice_sections {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the invoice sections that a user has access to. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn list_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
) -> list_by_billing_profile::RequestBuilder {
list_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
}
}
#[doc = "Gets an invoice section by its ID. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
pub fn get(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
}
}
#[doc = "Creates an invoice section. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `parameters`: Request parameters that are provided to the create invoice section operation."]
pub fn create(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
parameters: impl Into<models::InvoiceSectionCreationRequest>,
) -> create::RequestBuilder {
create::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Updates an invoice section. Currently, only displayName can be updated. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `parameters`: Request parameters that are provided to the update invoice section operation."]
pub fn update(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
parameters: impl Into<models::InvoiceSection>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Gives the caller permissions on an invoice section based on their billing profile access. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
pub fn elevate_to_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
) -> elevate_to_billing_profile::RequestBuilder {
elevate_to_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
}
}
}
pub mod list_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::InvoiceSectionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::InvoiceSectionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::InvoiceSectionListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::InvoiceSection> {
let bytes = self.0.into_body().collect().await?;
let body: models::InvoiceSection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::InvoiceSection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::InvoiceSection> {
let bytes = self.0.into_body().collect().await?;
let body: models::InvoiceSection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
pub fn headers(&self) -> Headers {
Headers(self.0.headers())
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
pub struct Headers<'a>(&'a azure_core::headers::Headers);
impl<'a> Headers<'a> {
#[doc = "Location URI to poll for result"]
pub fn location(&self) -> azure_core::Result<&str> {
self.0.get_str(&azure_core::headers::HeaderName::from_static("location"))
}
#[doc = "Recommended time to wait before making another request to check the status of the operation. The time is specified in seconds."]
pub fn retry_after(&self) -> azure_core::Result<i32> {
self.0.get_as(&azure_core::headers::HeaderName::from_static("retry-after"))
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) parameters: models::InvoiceSectionCreationRequest,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::InvoiceSection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::InvoiceSection> {
let bytes = self.0.into_body().collect().await?;
let body: models::InvoiceSection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
pub fn headers(&self) -> Headers {
Headers(self.0.headers())
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
pub struct Headers<'a>(&'a azure_core::headers::Headers);
impl<'a> Headers<'a> {
#[doc = "GET this URL to retrieve the status of the asynchronous operation."]
pub fn location(&self) -> azure_core::Result<&str> {
self.0.get_str(&azure_core::headers::HeaderName::from_static("location"))
}
#[doc = "The amount of delay to use while the status of the operation is checked. The value is expressed in seconds."]
pub fn retry_after(&self) -> azure_core::Result<&str> {
self.0.get_str(&azure_core::headers::HeaderName::from_static("retry-after"))
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) parameters: models::InvoiceSection,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::InvoiceSection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod elevate_to_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/elevate",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
}
pub mod billing_permissions {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the billing permissions the caller has for a customer."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
pub fn list_by_customer(
&self,
billing_account_name: impl Into<String>,
customer_name: impl Into<String>,
) -> list_by_customer::RequestBuilder {
list_by_customer::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
customer_name: customer_name.into(),
}
}
#[doc = "Lists the billing permissions the caller has on a billing account."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn list_by_billing_account(&self, billing_account_name: impl Into<String>) -> list_by_billing_account::RequestBuilder {
list_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
}
}
#[doc = "Lists the billing permissions the caller has on an invoice section."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
pub fn list_by_invoice_sections(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
) -> list_by_invoice_sections::RequestBuilder {
list_by_invoice_sections::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
}
}
#[doc = "Lists the billing permissions the caller has on a billing profile."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn list_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
) -> list_by_billing_profile::RequestBuilder {
list_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
}
}
#[doc = "Lists the billing permissions the caller has on a department."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `department_name`: The ID that uniquely identifies a department."]
pub fn list_by_department(
&self,
billing_account_name: impl Into<String>,
department_name: impl Into<String>,
) -> list_by_department::RequestBuilder {
list_by_department::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
department_name: department_name.into(),
}
}
#[doc = "Lists the billing permissions the caller has on an enrollment account."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `enrollment_account_name`: The ID that uniquely identifies an enrollment account."]
pub fn list_by_enrollment_account(
&self,
billing_account_name: impl Into<String>,
enrollment_account_name: impl Into<String>,
) -> list_by_enrollment_account::RequestBuilder {
list_by_enrollment_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
enrollment_account_name: enrollment_account_name.into(),
}
}
}
pub mod list_by_customer {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingPermissionsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingPermissionsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) customer_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/customers/{}/billingPermissions",
this.client.endpoint(),
&this.billing_account_name,
&this.customer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingPermissionsListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingPermissionsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingPermissionsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BillingPermissionsListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingPermissions",
this.client.endpoint(),
&this.billing_account_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_invoice_sections {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingPermissionsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingPermissionsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/billingPermissions",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingPermissionsListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingPermissionsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingPermissionsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/billingPermissions",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingPermissionsListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_department {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingPermissionsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingPermissionsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) department_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BillingPermissionsListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/departments/{}/billingPermissions",
this.client.endpoint(),
&this.billing_account_name,
&this.department_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_enrollment_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingPermissionsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingPermissionsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) enrollment_account_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BillingPermissionsListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/enrollmentAccounts/{}/billingPermissions",
this.client.endpoint(),
&this.billing_account_name,
&this.enrollment_account_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod billing_subscriptions {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the subscriptions for a customer. The operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
pub fn list_by_customer(
&self,
billing_account_name: impl Into<String>,
customer_name: impl Into<String>,
) -> list_by_customer::RequestBuilder {
list_by_customer::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
customer_name: customer_name.into(),
}
}
#[doc = "Gets a subscription by its ID. The operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
#[doc = "* `billing_subscription_name`: The ID that uniquely identifies a subscription."]
pub fn get_by_customer(
&self,
billing_account_name: impl Into<String>,
customer_name: impl Into<String>,
billing_subscription_name: impl Into<String>,
) -> get_by_customer::RequestBuilder {
get_by_customer::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
customer_name: customer_name.into(),
billing_subscription_name: billing_subscription_name.into(),
}
}
#[doc = "Lists the subscriptions for a billing account. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement or Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn list_by_billing_account(&self, billing_account_name: impl Into<String>) -> list_by_billing_account::RequestBuilder {
list_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
}
}
#[doc = "Lists the subscriptions that are billed to a billing profile. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement or Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn list_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
) -> list_by_billing_profile::RequestBuilder {
list_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
}
}
#[doc = "Lists the subscriptions that are billed to an invoice section. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
pub fn list_by_invoice_section(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
) -> list_by_invoice_section::RequestBuilder {
list_by_invoice_section::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
}
}
#[doc = "Gets a subscription by its ID. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `billing_subscription_name`: The ID that uniquely identifies a subscription."]
pub fn get(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
billing_subscription_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
billing_subscription_name: billing_subscription_name.into(),
}
}
#[doc = "Moves a subscription's charges to a new invoice section. The new invoice section must belong to the same billing profile as the existing invoice section. This operation is supported only for products that are purchased with a recurring charge and for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `billing_subscription_name`: The ID that uniquely identifies a subscription."]
#[doc = "* `parameters`: Request parameters that are provided to the transfer product operation."]
pub fn transfer(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
billing_subscription_name: impl Into<String>,
parameters: impl Into<models::TransferBillingSubscriptionRequestProperties>,
) -> transfer::RequestBuilder {
transfer::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
billing_subscription_name: billing_subscription_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Validates if a subscription's charges can be moved to a new invoice section. This operation is supported only for products that are purchased with a recurring charge and for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `billing_subscription_name`: The ID that uniquely identifies a subscription."]
#[doc = "* `parameters`: Request parameters that are provided to the validate transfer eligibility operation."]
pub fn validate_transfer(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
billing_subscription_name: impl Into<String>,
parameters: impl Into<models::TransferBillingSubscriptionRequestProperties>,
) -> validate_transfer::RequestBuilder {
validate_transfer::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
billing_subscription_name: billing_subscription_name.into(),
parameters: parameters.into(),
}
}
}
pub mod list_by_customer {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingSubscriptionsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingSubscriptionsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) customer_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BillingSubscriptionsListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/customers/{}/billingSubscriptions",
this.client.endpoint(),
&this.billing_account_name,
&this.customer_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_by_customer {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingSubscription> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingSubscription = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) customer_name: String,
pub(crate) billing_subscription_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/customers/{}/billingSubscriptions/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.customer_name,
&this.billing_subscription_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingSubscription>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingSubscriptionsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingSubscriptionsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BillingSubscriptionsListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingSubscriptions",
this.client.endpoint(),
&this.billing_account_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingSubscriptionsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingSubscriptionsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/billingSubscriptions",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingSubscriptionsListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_invoice_section {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingSubscriptionsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingSubscriptionsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/billingSubscriptions",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingSubscriptionsListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingSubscription> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingSubscription = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) billing_subscription_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/billingSubscriptions/{}" , this . client . endpoint () , & this . billing_account_name , & this . billing_profile_name , & this . invoice_section_name , & this . billing_subscription_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingSubscription>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod transfer {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransferBillingSubscriptionResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransferBillingSubscriptionResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
pub fn headers(&self) -> Headers {
Headers(self.0.headers())
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
pub struct Headers<'a>(&'a azure_core::headers::Headers);
impl<'a> Headers<'a> {
#[doc = "Location URI to poll for result."]
pub fn location(&self) -> azure_core::Result<&str> {
self.0.get_str(&azure_core::headers::HeaderName::from_static("location"))
}
#[doc = "Recommended time to wait before making another request to check the status of the operation. The time is specified in seconds."]
pub fn retry_after(&self) -> azure_core::Result<i32> {
self.0.get_as(&azure_core::headers::HeaderName::from_static("retry-after"))
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) billing_subscription_name: String,
pub(crate) parameters: models::TransferBillingSubscriptionRequestProperties,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/billingSubscriptions/{}/transfer" , this . client . endpoint () , & this . billing_account_name , & this . billing_profile_name , & this . invoice_section_name , & this . billing_subscription_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TransferBillingSubscriptionResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod validate_transfer {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ValidateSubscriptionTransferEligibilityResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::ValidateSubscriptionTransferEligibilityResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) billing_subscription_name: String,
pub(crate) parameters: models::TransferBillingSubscriptionRequestProperties,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/billingSubscriptions/{}/validateTransferEligibility" , this . client . endpoint () , & this . billing_account_name , & this . billing_profile_name , & this . invoice_section_name , & this . billing_subscription_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::ValidateSubscriptionTransferEligibilityResult>>
{
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod products {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the products for a customer. These don't include products billed based on usage.The operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
pub fn list_by_customer(
&self,
billing_account_name: impl Into<String>,
customer_name: impl Into<String>,
) -> list_by_customer::RequestBuilder {
list_by_customer::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
customer_name: customer_name.into(),
filter: None,
}
}
#[doc = "Gets a product by ID. The operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
#[doc = "* `product_name`: The ID that uniquely identifies a product."]
pub fn get_by_customer(
&self,
billing_account_name: impl Into<String>,
customer_name: impl Into<String>,
product_name: impl Into<String>,
) -> get_by_customer::RequestBuilder {
get_by_customer::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
customer_name: customer_name.into(),
product_name: product_name.into(),
}
}
#[doc = "Lists the products for a billing account. These don't include products billed based on usage. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement or Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn list_by_billing_account(&self, billing_account_name: impl Into<String>) -> list_by_billing_account::RequestBuilder {
list_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
filter: None,
}
}
#[doc = "Lists the products for an invoice section. These don't include products billed based on usage. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
pub fn list_by_invoice_section(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
) -> list_by_invoice_section::RequestBuilder {
list_by_invoice_section::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
filter: None,
}
}
#[doc = "Gets a product by ID. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `product_name`: The ID that uniquely identifies a product."]
pub fn get(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
product_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
product_name: product_name.into(),
}
}
#[doc = "Moves a product's charges to a new invoice section. The new invoice section must belong to the same billing profile as the existing invoice section. This operation is supported only for products that are purchased with a recurring charge and for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `product_name`: The ID that uniquely identifies a product."]
#[doc = "* `parameters`: Request parameters that are provided to the transfer product operation."]
pub fn transfer(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
product_name: impl Into<String>,
parameters: impl Into<models::TransferProductRequestProperties>,
) -> transfer::RequestBuilder {
transfer::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
product_name: product_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Validates if a product's charges can be moved to a new invoice section. This operation is supported only for products that are purchased with a recurring charge and for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `product_name`: The ID that uniquely identifies a product."]
#[doc = "* `parameters`: Request parameters that are provided to the validate transfer eligibility operation."]
pub fn validate_transfer(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
product_name: impl Into<String>,
parameters: impl Into<models::TransferProductRequestProperties>,
) -> validate_transfer::RequestBuilder {
validate_transfer::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
product_name: product_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Cancel auto renew for product by product id and invoice section name"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `product_name`: The ID that uniquely identifies a product."]
#[doc = "* `body`: Request parameters that are provided to the update auto renew operation."]
pub fn update_auto_renew_by_invoice_section(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
product_name: impl Into<String>,
body: impl Into<models::UpdateAutoRenewRequest>,
) -> update_auto_renew_by_invoice_section::RequestBuilder {
update_auto_renew_by_invoice_section::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
product_name: product_name.into(),
body: body.into(),
}
}
}
pub mod list_by_customer {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProductsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProductsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) customer_name: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to filter by product type. The filter supports 'eq', 'lt', 'gt', 'le', 'ge', and 'and'. It does not currently support 'ne', 'or', or 'not'. Tag filter is a key value pair string where key and value are separated by a colon (:)."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/customers/{}/products",
this.client.endpoint(),
&this.billing_account_name,
&this.customer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ProductsListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_by_customer {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Product> {
let bytes = self.0.into_body().collect().await?;
let body: models::Product = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) customer_name: String,
pub(crate) product_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/customers/{}/products/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.customer_name,
&this.product_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Product>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProductsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProductsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to filter by product type. The filter supports 'eq', 'lt', 'gt', 'le', 'ge', and 'and'. It does not currently support 'ne', 'or', or 'not'. Tag filter is a key value pair string where key and value are separated by a colon (:)."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::ProductsListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/products",
this.client.endpoint(),
&this.billing_account_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_invoice_section {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProductsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProductsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to filter by product type. The filter supports 'eq', 'lt', 'gt', 'le', 'ge', and 'and'. It does not currently support 'ne', 'or', or 'not'. Tag filter is a key value pair string where key and value are separated by a colon (:)."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/products",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ProductsListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Product> {
let bytes = self.0.into_body().collect().await?;
let body: models::Product = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) product_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/products/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name,
&this.product_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Product>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod transfer {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Product> {
let bytes = self.0.into_body().collect().await?;
let body: models::Product = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
pub fn headers(&self) -> Headers {
Headers(self.0.headers())
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
pub struct Headers<'a>(&'a azure_core::headers::Headers);
impl<'a> Headers<'a> {
#[doc = "Location URI to poll for result"]
pub fn location(&self) -> azure_core::Result<&str> {
self.0.get_str(&azure_core::headers::HeaderName::from_static("location"))
}
#[doc = "Recommended time to wait before making another request to check the status of the operation. The time is specified in seconds."]
pub fn retry_after(&self) -> azure_core::Result<i32> {
self.0.get_as(&azure_core::headers::HeaderName::from_static("retry-after"))
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) product_name: String,
pub(crate) parameters: models::TransferProductRequestProperties,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/products/{}/transfer",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name,
&this.product_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Product>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod validate_transfer {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ValidateProductTransferEligibilityResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::ValidateProductTransferEligibilityResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) product_name: String,
pub(crate) parameters: models::TransferProductRequestProperties,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/products/{}/validateTransferEligibility" , this . client . endpoint () , & this . billing_account_name , & this . billing_profile_name , & this . invoice_section_name , & this . product_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::ValidateProductTransferEligibilityResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_auto_renew_by_invoice_section {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::UpdateAutoRenewOperation> {
let bytes = self.0.into_body().collect().await?;
let body: models::UpdateAutoRenewOperation = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) product_name: String,
pub(crate) body: models::UpdateAutoRenewRequest,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/products/{}/updateAutoRenew" , this . client . endpoint () , & this . billing_account_name , & this . billing_profile_name , & this . invoice_section_name , & this . product_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::UpdateAutoRenewOperation>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod transactions {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the billed and unbilled transactions by customer id for given start date and end date. Transactions include purchases, refunds and Azure usage charges. Unbilled transactions are listed under pending invoice Id and do not include tax. Tax is added to the amount once an invoice is generated."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
#[doc = "* `period_start_date`: The start date to fetch the transactions. The date should be specified in MM-DD-YYYY format."]
#[doc = "* `period_end_date`: The end date to fetch the transactions. The date should be specified in MM-DD-YYYY format."]
pub fn list_by_customer(
&self,
billing_account_name: impl Into<String>,
customer_name: impl Into<String>,
period_start_date: impl Into<String>,
period_end_date: impl Into<String>,
) -> list_by_customer::RequestBuilder {
list_by_customer::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
customer_name: customer_name.into(),
period_start_date: period_start_date.into(),
period_end_date: period_end_date.into(),
filter: None,
}
}
#[doc = "Lists the billed and unbilled transactions by billing account name for given start and end date. Transactions include purchases, refunds and Azure usage charges. Unbilled transactions are listed under pending invoice ID and do not include tax. Tax is added to the amount once an invoice is generated."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `period_start_date`: The start date to fetch the transactions. The date should be specified in MM-DD-YYYY format."]
#[doc = "* `period_end_date`: The end date to fetch the transactions. The date should be specified in MM-DD-YYYY format."]
pub fn list_by_billing_account(
&self,
billing_account_name: impl Into<String>,
period_start_date: impl Into<String>,
period_end_date: impl Into<String>,
) -> list_by_billing_account::RequestBuilder {
list_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
period_start_date: period_start_date.into(),
period_end_date: period_end_date.into(),
filter: None,
}
}
#[doc = "Lists the billed and unbilled transactions by billing profile name for given start date and end date. Transactions include purchases, refunds and Azure usage charges. Unbilled transactions are listed under pending invoice Id and do not include tax. Tax is added to the amount once an invoice is generated."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `period_start_date`: The start date to fetch the transactions. The date should be specified in MM-DD-YYYY format."]
#[doc = "* `period_end_date`: The end date to fetch the transactions. The date should be specified in MM-DD-YYYY format."]
pub fn list_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
period_start_date: impl Into<String>,
period_end_date: impl Into<String>,
) -> list_by_billing_profile::RequestBuilder {
list_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
period_start_date: period_start_date.into(),
period_end_date: period_end_date.into(),
filter: None,
}
}
#[doc = "Lists the billed and unbilled transactions by invoice section name for given start date and end date. Transactions include purchases, refunds and Azure usage charges. Unbilled transactions are listed under pending invoice Id and do not include tax. Tax is added to the amount once an invoice is generated."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `period_start_date`: The start date to fetch the transactions. The date should be specified in MM-DD-YYYY format."]
#[doc = "* `period_end_date`: The end date to fetch the transactions. The date should be specified in MM-DD-YYYY format."]
pub fn list_by_invoice_section(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
period_start_date: impl Into<String>,
period_end_date: impl Into<String>,
) -> list_by_invoice_section::RequestBuilder {
list_by_invoice_section::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
period_start_date: period_start_date.into(),
period_end_date: period_end_date.into(),
filter: None,
}
}
#[doc = "Lists the transactions for an invoice. Transactions include purchases, refunds and Azure usage charges."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_name`: The ID that uniquely identifies an invoice."]
pub fn list_by_invoice(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_name: impl Into<String>,
) -> list_by_invoice::RequestBuilder {
list_by_invoice::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_name: invoice_name.into(),
}
}
#[doc = "Gets a transaction by ID. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement or Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `transaction_name`: The ID that uniquely identifies a transaction."]
#[doc = "* `period_start_date`: The start date to fetch the transactions. The date should be specified in MM-DD-YYYY format."]
#[doc = "* `period_end_date`: The end date to fetch the transactions. The date should be specified in MM-DD-YYYY format."]
pub fn get(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
transaction_name: impl Into<String>,
period_start_date: impl Into<String>,
period_end_date: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
transaction_name: transaction_name.into(),
period_start_date: period_start_date.into(),
period_end_date: period_end_date.into(),
}
}
}
pub mod list_by_customer {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransactionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransactionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) customer_name: String,
pub(crate) period_start_date: String,
pub(crate) period_end_date: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to filter by transaction type. The filter supports 'eq', 'lt', 'gt', 'le', 'ge', and 'and'. It does not currently support 'ne', 'or', or 'not'. Tag filter is a key value pair string where key and value are separated by a colon (:)."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::TransactionListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/customers/{}/transactions",
this.client.endpoint(),
&this.billing_account_name,
&this.customer_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let period_start_date = &this.period_start_date;
req.url_mut().query_pairs_mut().append_pair("periodStartDate", period_start_date);
let period_end_date = &this.period_end_date;
req.url_mut().query_pairs_mut().append_pair("periodEndDate", period_end_date);
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransactionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransactionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) period_start_date: String,
pub(crate) period_end_date: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to filter by transaction type. The filter supports 'eq', 'lt', 'gt', 'le', 'ge', and 'and'. It does not currently support 'ne', 'or', or 'not'. Tag filter is a key value pair string where key and value are separated by a colon (:)."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::TransactionListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/transactions",
this.client.endpoint(),
&this.billing_account_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let period_start_date = &this.period_start_date;
req.url_mut().query_pairs_mut().append_pair("periodStartDate", period_start_date);
let period_end_date = &this.period_end_date;
req.url_mut().query_pairs_mut().append_pair("periodEndDate", period_end_date);
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransactionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransactionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) period_start_date: String,
pub(crate) period_end_date: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to filter by transaction type. The filter supports 'eq', 'lt', 'gt', 'le', 'ge', and 'and'. It does not currently support 'ne', 'or', or 'not'. Tag filter is a key value pair string where key and value are separated by a colon (:)."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/transactions",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let period_start_date = &this.period_start_date;
req.url_mut().query_pairs_mut().append_pair("periodStartDate", period_start_date);
let period_end_date = &this.period_end_date;
req.url_mut().query_pairs_mut().append_pair("periodEndDate", period_end_date);
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TransactionListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_invoice_section {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransactionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransactionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) period_start_date: String,
pub(crate) period_end_date: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to filter by transaction type. The filter supports 'eq', 'lt', 'gt', 'le', 'ge', and 'and'. It does not currently support 'ne', 'or', or 'not'. Tag filter is a key value pair string where key and value are separated by a colon (:)."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/transactions",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let period_start_date = &this.period_start_date;
req.url_mut().query_pairs_mut().append_pair("periodStartDate", period_start_date);
let period_end_date = &this.period_end_date;
req.url_mut().query_pairs_mut().append_pair("periodEndDate", period_end_date);
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TransactionListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_invoice {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransactionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransactionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::TransactionListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoices/{}/transactions",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Transaction> {
let bytes = self.0.into_body().collect().await?;
let body: models::Transaction = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) transaction_name: String,
pub(crate) period_start_date: String,
pub(crate) period_end_date: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/transactions/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.transaction_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let period_start_date = &this.period_start_date;
req.url_mut().query_pairs_mut().append_pair("periodStartDate", period_start_date);
let period_end_date = &this.period_end_date;
req.url_mut().query_pairs_mut().append_pair("periodEndDate", period_end_date);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Transaction>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod departments {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the departments that a user has access to. The operation is supported only for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn list_by_billing_account_name(
&self,
billing_account_name: impl Into<String>,
) -> list_by_billing_account_name::RequestBuilder {
list_by_billing_account_name::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
expand: None,
filter: None,
}
}
#[doc = "Gets a department by ID. The operation is supported only for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `department_name`: The ID that uniquely identifies a department."]
pub fn get(&self, billing_account_name: impl Into<String>, department_name: impl Into<String>) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
department_name: department_name.into(),
expand: None,
filter: None,
}
}
}
pub mod list_by_billing_account_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DepartmentListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::DepartmentListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) expand: Option<String>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to expand the enrollment accounts."]
pub fn expand(mut self, expand: impl Into<String>) -> Self {
self.expand = Some(expand.into());
self
}
#[doc = "May be used to filter by department name. The filter supports 'eq', 'lt', 'gt', 'le', 'ge', and 'and'. It does not currently support 'ne', 'or', or 'not'. Tag filter is a key value pair string where key and value are separated by a colon (:)."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/departments",
this.client.endpoint(),
&this.billing_account_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(expand) = &this.expand {
req.url_mut().query_pairs_mut().append_pair("$expand", expand);
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DepartmentListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Department> {
let bytes = self.0.into_body().collect().await?;
let body: models::Department = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) department_name: String,
pub(crate) expand: Option<String>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to expand the enrollment accounts."]
pub fn expand(mut self, expand: impl Into<String>) -> Self {
self.expand = Some(expand.into());
self
}
#[doc = "May be used to filter by department name. The filter supports 'eq', 'lt', 'gt', 'le', 'ge', and 'and'. It does not currently support 'ne', 'or', or 'not'. Tag filter is a key value pair string where key and value are separated by a colon (:)."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/departments/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.department_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(expand) = &this.expand {
req.url_mut().query_pairs_mut().append_pair("$expand", expand);
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Department>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod enrollment_accounts {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the enrollment accounts for a billing account. The operation is supported only for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn list_by_billing_account_name(
&self,
billing_account_name: impl Into<String>,
) -> list_by_billing_account_name::RequestBuilder {
list_by_billing_account_name::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
expand: None,
filter: None,
}
}
#[doc = "Gets an enrollment account by ID. The operation is supported only for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `enrollment_account_name`: The ID that uniquely identifies an enrollment account."]
pub fn get_by_enrollment_account_id(
&self,
billing_account_name: impl Into<String>,
enrollment_account_name: impl Into<String>,
) -> get_by_enrollment_account_id::RequestBuilder {
get_by_enrollment_account_id::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
enrollment_account_name: enrollment_account_name.into(),
expand: None,
filter: None,
}
}
}
pub mod list_by_billing_account_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::EnrollmentAccountListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::EnrollmentAccountListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) expand: Option<String>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to expand the department."]
pub fn expand(mut self, expand: impl Into<String>) -> Self {
self.expand = Some(expand.into());
self
}
#[doc = "May be used to filter by account name. The filter supports 'eq', 'lt', 'gt', 'le', 'ge', and 'and'. It does not currently support 'ne', 'or', or 'not'. Tag filter is a key value pair string where key and value are separated by a colon (:)."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/enrollmentAccounts",
this.client.endpoint(),
&this.billing_account_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(expand) = &this.expand {
req.url_mut().query_pairs_mut().append_pair("$expand", expand);
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::EnrollmentAccountListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_by_enrollment_account_id {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::EnrollmentAccount> {
let bytes = self.0.into_body().collect().await?;
let body: models::EnrollmentAccount = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) enrollment_account_name: String,
pub(crate) expand: Option<String>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to expand the department."]
pub fn expand(mut self, expand: impl Into<String>) -> Self {
self.expand = Some(expand.into());
self
}
#[doc = "May be used to filter by account name. The filter supports 'eq', 'lt', 'gt', 'le', 'ge', and 'and'. It does not currently support 'ne', 'or', or 'not'. Tag filter is a key value pair string where key and value are separated by a colon (:)."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/enrollmentAccounts/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.enrollment_account_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(expand) = &this.expand {
req.url_mut().query_pairs_mut().append_pair("$expand", expand);
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::EnrollmentAccount>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod invoices {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the invoices for a billing account for a given start date and end date. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement, Microsoft Customer Agreement or Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `period_start_date`: The start date to fetch the invoices. The date should be specified in MM-DD-YYYY format."]
#[doc = "* `period_end_date`: The end date to fetch the invoices. The date should be specified in MM-DD-YYYY format."]
pub fn list_by_billing_account(
&self,
billing_account_name: impl Into<String>,
period_start_date: impl Into<String>,
period_end_date: impl Into<String>,
) -> list_by_billing_account::RequestBuilder {
list_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
period_start_date: period_start_date.into(),
period_end_date: period_end_date.into(),
}
}
#[doc = "Gets a URL to download multiple invoice documents (invoice pdf, tax receipts, credit notes) as a zip file."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `download_urls`: An array of download urls for individual documents. The download url paths in the request body should match the path of the original request."]
pub fn download_multiple_ea_invoices(
&self,
billing_account_name: impl Into<String>,
download_urls: Vec<String>,
) -> download_multiple_ea_invoices::RequestBuilder {
download_multiple_ea_invoices::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
download_urls,
}
}
#[doc = "Gets an invoice by billing account name and ID. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement, Microsoft Customer Agreement or Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `invoice_name`: The ID that uniquely identifies an invoice."]
pub fn get_billing_account_invoice(
&self,
billing_account_name: impl Into<String>,
invoice_name: impl Into<String>,
) -> get_billing_account_invoice::RequestBuilder {
get_billing_account_invoice::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
invoice_name: invoice_name.into(),
}
}
#[doc = "Gets a URL to download multiple invoice documents (invoice pdf, tax receipts, credit notes) as a zip file."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID that uniquely identifies an Azure subscription."]
#[doc = "* `download_urls`: An array of download urls for individual documents. The download url paths in the request body should match the path of the original request."]
pub fn download_multiple_billing_subscription_invoices(
&self,
subscription_id: impl Into<String>,
download_urls: Vec<String>,
) -> download_multiple_billing_subscription_invoices::RequestBuilder {
download_multiple_billing_subscription_invoices::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
download_urls,
}
}
#[doc = "Lists the invoices for a billing profile for a given start date and end date. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement or Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `period_start_date`: The start date to fetch the invoices. The date should be specified in MM-DD-YYYY format."]
#[doc = "* `period_end_date`: The end date to fetch the invoices. The date should be specified in MM-DD-YYYY format."]
pub fn list_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
period_start_date: impl Into<String>,
period_end_date: impl Into<String>,
) -> list_by_billing_profile::RequestBuilder {
list_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
period_start_date: period_start_date.into(),
period_end_date: period_end_date.into(),
}
}
#[doc = "Gets a URL to download multiple invoice documents (invoice pdf, tax receipts, credit notes) as a zip file."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `download_urls`: An array of download urls for individual documents. The download url paths in the request body should match the path of the original request."]
pub fn download_multiple_billing_profile_invoices(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
download_urls: Vec<String>,
) -> download_multiple_billing_profile_invoices::RequestBuilder {
download_multiple_billing_profile_invoices::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
download_urls,
}
}
#[doc = "Gets an invoice by ID. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement or Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_name`: The ID that uniquely identifies an invoice."]
pub fn get(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_name: invoice_name.into(),
}
}
#[doc = "Lists the invoices for a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_subscription_name`: The ID that uniquely identifies a subscription."]
#[doc = "* `period_start_date`: Invoice period start date."]
#[doc = "* `period_end_date`: Invoice period end date."]
pub fn list_by_billing_subscription(
&self,
billing_account_name: impl Into<String>,
billing_subscription_name: impl Into<String>,
period_start_date: impl Into<String>,
period_end_date: impl Into<String>,
) -> list_by_billing_subscription::RequestBuilder {
list_by_billing_subscription::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_subscription_name: billing_subscription_name.into(),
period_start_date: period_start_date.into(),
period_end_date: period_end_date.into(),
}
}
#[doc = "Gets an invoice by ID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_subscription_name`: The ID that uniquely identifies a subscription."]
#[doc = "* `invoice_name`: The ID that uniquely identifies an invoice."]
pub fn get_by_id(
&self,
billing_account_name: impl Into<String>,
billing_subscription_name: impl Into<String>,
invoice_name: impl Into<String>,
) -> get_by_id::RequestBuilder {
get_by_id::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_subscription_name: billing_subscription_name.into(),
invoice_name: invoice_name.into(),
}
}
}
pub mod list_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::InvoiceListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::InvoiceListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) period_start_date: String,
pub(crate) period_end_date: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/invoices",
this.client.endpoint(),
&this.billing_account_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let period_start_date = &this.period_start_date;
req.url_mut().query_pairs_mut().append_pair("periodStartDate", period_start_date);
let period_end_date = &this.period_end_date;
req.url_mut().query_pairs_mut().append_pair("periodEndDate", period_end_date);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::InvoiceListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod download_multiple_ea_invoices {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) download_urls: Vec<String>,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/downloadDocuments",
this.client.endpoint(),
&this.billing_account_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.download_urls)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_billing_account_invoice {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Invoice> {
let bytes = self.0.into_body().collect().await?;
let body: models::Invoice = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) invoice_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/invoices/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.invoice_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Invoice>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod download_multiple_billing_subscription_invoices {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) download_urls: Vec<String>,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/default/billingSubscriptions/{}/downloadDocuments",
this.client.endpoint(),
&this.subscription_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.download_urls)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::InvoiceListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::InvoiceListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) period_start_date: String,
pub(crate) period_end_date: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoices",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let period_start_date = &this.period_start_date;
req.url_mut().query_pairs_mut().append_pair("periodStartDate", period_start_date);
let period_end_date = &this.period_end_date;
req.url_mut().query_pairs_mut().append_pair("periodEndDate", period_end_date);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::InvoiceListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod download_multiple_billing_profile_invoices {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) download_urls: Vec<String>,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/downloadDocuments",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.download_urls)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Invoice> {
let bytes = self.0.into_body().collect().await?;
let body: models::Invoice = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoices/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Invoice>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_billing_subscription {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::InvoiceListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::InvoiceListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_subscription_name: String,
pub(crate) period_start_date: String,
pub(crate) period_end_date: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::InvoiceListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingSubscriptions/{}/invoices",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_subscription_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let period_start_date = &this.period_start_date;
req.url_mut().query_pairs_mut().append_pair("periodStartDate", period_start_date);
let period_end_date = &this.period_end_date;
req.url_mut().query_pairs_mut().append_pair("periodEndDate", period_end_date);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_by_id {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Invoice> {
let bytes = self.0.into_body().collect().await?;
let body: models::Invoice = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_subscription_name: String,
pub(crate) invoice_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingSubscriptions/{}/invoices/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_subscription_name,
&this.invoice_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Invoice>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod price_sheet {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Gets a URL to download the pricesheet for an invoice. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement or Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_name`: The ID that uniquely identifies an invoice."]
pub fn download(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_name: impl Into<String>,
) -> download::RequestBuilder {
download::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_name: invoice_name.into(),
}
}
#[doc = "Gets a URL to download the current month's pricesheet for a billing profile. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement or Microsoft Customer Agreement.This API is hereby deprecated in favor of https://docs.microsoft.com/en-us/rest/api/cost-management/2022-02-01-preview/price-sheet/download-by-billing-profile. We highly recommend you move to the new preview version, as the csv file in the current preview version will have 500k max size that cannot scale with Azure product growth."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn download_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
) -> download_by_billing_profile::RequestBuilder {
download_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
}
}
}
pub mod download {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_name: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoices/{}/pricesheet/default/download",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod download_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/pricesheet/default/download",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
}
pub mod policies {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the policies for a billing profile. This operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn get_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
) -> get_by_billing_profile::RequestBuilder {
get_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
}
}
#[doc = "Updates the policies for a billing profile. This operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `parameters`: Request parameters that are provided to the update policies operation."]
pub fn update(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
parameters: impl Into<models::Policy>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Lists the policies for a customer. This operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
pub fn get_by_customer(
&self,
billing_account_name: impl Into<String>,
customer_name: impl Into<String>,
) -> get_by_customer::RequestBuilder {
get_by_customer::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
customer_name: customer_name.into(),
}
}
#[doc = "Updates the policies for a customer. This operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
#[doc = "* `parameters`: Request parameters that are provided to the update policies operation."]
pub fn update_customer(
&self,
billing_account_name: impl Into<String>,
customer_name: impl Into<String>,
parameters: impl Into<models::CustomerPolicy>,
) -> update_customer::RequestBuilder {
update_customer::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
customer_name: customer_name.into(),
parameters: parameters.into(),
}
}
}
pub mod get_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Policy> {
let bytes = self.0.into_body().collect().await?;
let body: models::Policy = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/policies/default",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Policy>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Policy> {
let bytes = self.0.into_body().collect().await?;
let body: models::Policy = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) parameters: models::Policy,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/policies/default",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Policy>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_by_customer {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CustomerPolicy> {
let bytes = self.0.into_body().collect().await?;
let body: models::CustomerPolicy = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) customer_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/customers/{}/policies/default",
this.client.endpoint(),
&this.billing_account_name,
&this.customer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::CustomerPolicy>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_customer {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CustomerPolicy> {
let bytes = self.0.into_body().collect().await?;
let body: models::CustomerPolicy = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) customer_name: String,
pub(crate) parameters: models::CustomerPolicy,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/customers/{}/policies/default",
this.client.endpoint(),
&this.billing_account_name,
&this.customer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::CustomerPolicy>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod billing_property {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get the billing properties for a subscription. This operation is not supported for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID that uniquely identifies an Azure subscription."]
pub fn get(&self, subscription_id: impl Into<String>) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingProperty> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingProperty = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Billing/billingProperty/default",
this.client.endpoint(),
&this.subscription_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingProperty>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod transfers {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Sends a request to a user in another billing account to transfer billing ownership of their subscriptions. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `parameters`: Request parameters that are provided to the initiate transfer operation."]
pub fn initiate(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
parameters: impl Into<models::InitiateTransferRequest>,
) -> initiate::RequestBuilder {
initiate::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Gets a transfer request by ID. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `transfer_name`: The ID that uniquely identifies a transfer request."]
pub fn get(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
transfer_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
transfer_name: transfer_name.into(),
}
}
#[doc = "Cancels a transfer request. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `transfer_name`: The ID that uniquely identifies a transfer request."]
pub fn cancel(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
transfer_name: impl Into<String>,
) -> cancel::RequestBuilder {
cancel::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
transfer_name: transfer_name.into(),
}
}
#[doc = "Lists the transfer requests for an invoice section. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
pub fn list(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
}
}
}
pub mod initiate {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransferDetails> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransferDetails = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) parameters: models::InitiateTransferRequest,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/initiateTransfer",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TransferDetails>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransferDetails> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransferDetails = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) transfer_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/transfers/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name,
&this.transfer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TransferDetails>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod cancel {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransferDetails> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransferDetails = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) transfer_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/transfers/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name,
&this.transfer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TransferDetails>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransferDetailsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransferDetailsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::TransferDetailsListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/transfers",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.invoice_section_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod partner_transfers {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Sends a request to a user in a customer's billing account to transfer billing ownership of their subscriptions. The operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
#[doc = "* `parameters`: Request parameters that are provided to the initiate transfer operation."]
pub fn initiate(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
customer_name: impl Into<String>,
parameters: impl Into<models::InitiateTransferRequest>,
) -> initiate::RequestBuilder {
initiate::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
customer_name: customer_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Gets a transfer request by ID. The operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
#[doc = "* `transfer_name`: The ID that uniquely identifies a transfer request."]
pub fn get(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
customer_name: impl Into<String>,
transfer_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
customer_name: customer_name.into(),
transfer_name: transfer_name.into(),
}
}
#[doc = "Cancels a transfer request. The operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
#[doc = "* `transfer_name`: The ID that uniquely identifies a transfer request."]
pub fn cancel(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
customer_name: impl Into<String>,
transfer_name: impl Into<String>,
) -> cancel::RequestBuilder {
cancel::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
customer_name: customer_name.into(),
transfer_name: transfer_name.into(),
}
}
#[doc = "Lists the transfer requests sent to a customer. The operation is supported only for billing accounts with agreement type Microsoft Partner Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `customer_name`: The ID that uniquely identifies a customer."]
pub fn list(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
customer_name: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
customer_name: customer_name.into(),
}
}
}
pub mod initiate {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransferDetails> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransferDetails = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) customer_name: String,
pub(crate) parameters: models::InitiateTransferRequest,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/customers/{}/initiateTransfer",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.customer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TransferDetails>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransferDetails> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransferDetails = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) customer_name: String,
pub(crate) transfer_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/customers/{}/transfers/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.customer_name,
&this.transfer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TransferDetails>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod cancel {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransferDetails> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransferDetails = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) customer_name: String,
pub(crate) transfer_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/customers/{}/transfers/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.customer_name,
&this.transfer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TransferDetails>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TransferDetailsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::TransferDetailsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) customer_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::TransferDetailsListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/customers/{}/transfers",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.customer_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod recipient_transfers {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Accepts a transfer request."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `transfer_name`: The ID that uniquely identifies a transfer request."]
#[doc = "* `parameters`: Request parameters that are provided to the accept transfer operation."]
pub fn accept(
&self,
transfer_name: impl Into<String>,
parameters: impl Into<models::AcceptTransferRequest>,
) -> accept::RequestBuilder {
accept::RequestBuilder {
client: self.0.clone(),
transfer_name: transfer_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Validates if a subscription or a reservation can be transferred. Use this operation to validate your subscriptions or reservation before using the accept transfer operation."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `transfer_name`: The ID that uniquely identifies a transfer request."]
#[doc = "* `parameters`: Request parameters that are provided to the validate transfer operation."]
pub fn validate(
&self,
transfer_name: impl Into<String>,
parameters: impl Into<models::AcceptTransferRequest>,
) -> validate::RequestBuilder {
validate::RequestBuilder {
client: self.0.clone(),
transfer_name: transfer_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Declines a transfer request."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `transfer_name`: The ID that uniquely identifies a transfer request."]
pub fn decline(&self, transfer_name: impl Into<String>) -> decline::RequestBuilder {
decline::RequestBuilder {
client: self.0.clone(),
transfer_name: transfer_name.into(),
}
}
#[doc = "Gets a transfer request by ID. The caller must be the recipient of the transfer request."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `transfer_name`: The ID that uniquely identifies a transfer request."]
pub fn get(&self, transfer_name: impl Into<String>) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
transfer_name: transfer_name.into(),
}
}
#[doc = "Lists the transfer requests received by the caller."]
pub fn list(&self) -> list::RequestBuilder {
list::RequestBuilder { client: self.0.clone() }
}
}
pub mod accept {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RecipientTransferDetails> {
let bytes = self.0.into_body().collect().await?;
let body: models::RecipientTransferDetails = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) transfer_name: String,
pub(crate) parameters: models::AcceptTransferRequest,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/transfers/{}/acceptTransfer",
this.client.endpoint(),
&this.transfer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RecipientTransferDetails>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod validate {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ValidateTransferListResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::ValidateTransferListResponse = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) transfer_name: String,
pub(crate) parameters: models::AcceptTransferRequest,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/transfers/{}/validateTransfer",
this.client.endpoint(),
&this.transfer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ValidateTransferListResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod decline {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RecipientTransferDetails> {
let bytes = self.0.into_body().collect().await?;
let body: models::RecipientTransferDetails = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) transfer_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/transfers/{}/declineTransfer",
this.client.endpoint(),
&this.transfer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RecipientTransferDetails>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RecipientTransferDetails> {
let bytes = self.0.into_body().collect().await?;
let body: models::RecipientTransferDetails = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) transfer_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/transfers/{}",
this.client.endpoint(),
&this.transfer_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RecipientTransferDetails>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RecipientTransferDetailsListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::RecipientTransferDetailsListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::RecipientTransferDetailsListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url =
azure_core::Url::parse(&format!("{}/providers/Microsoft.Billing/transfers", this.client.endpoint(),))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod operations {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the available billing REST API operations."]
pub fn list(&self) -> list::RequestBuilder {
list::RequestBuilder { client: self.0.clone() }
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::OperationListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::OperationListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::OperationListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url =
azure_core::Url::parse(&format!("{}/providers/Microsoft.Billing/operations", this.client.endpoint(),))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod billing_role_definitions {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Gets the definition for a role on a billing account. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement or Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_role_definition_name`: The ID that uniquely identifies a role definition."]
pub fn get_by_billing_account(
&self,
billing_account_name: impl Into<String>,
billing_role_definition_name: impl Into<String>,
) -> get_by_billing_account::RequestBuilder {
get_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_role_definition_name: billing_role_definition_name.into(),
}
}
#[doc = "Gets the definition for a role on an invoice section. The operation is supported only for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `billing_role_definition_name`: The ID that uniquely identifies a role definition."]
pub fn get_by_invoice_section(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
billing_role_definition_name: impl Into<String>,
) -> get_by_invoice_section::RequestBuilder {
get_by_invoice_section::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
billing_role_definition_name: billing_role_definition_name.into(),
}
}
#[doc = "Gets the definition for a role on a billing profile. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement or Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `billing_role_definition_name`: The ID that uniquely identifies a role definition."]
pub fn get_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
billing_role_definition_name: impl Into<String>,
) -> get_by_billing_profile::RequestBuilder {
get_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
billing_role_definition_name: billing_role_definition_name.into(),
}
}
#[doc = "Gets the definition for a role on a department. The operation is supported only for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `department_name`: The ID that uniquely identifies a department."]
#[doc = "* `billing_role_definition_name`: The ID that uniquely identifies a role definition."]
pub fn get_by_department(
&self,
billing_account_name: impl Into<String>,
department_name: impl Into<String>,
billing_role_definition_name: impl Into<String>,
) -> get_by_department::RequestBuilder {
get_by_department::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
department_name: department_name.into(),
billing_role_definition_name: billing_role_definition_name.into(),
}
}
#[doc = "Gets the definition for a role on an enrollment account. The operation is supported only for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `enrollment_account_name`: The ID that uniquely identifies an enrollment account."]
#[doc = "* `billing_role_definition_name`: The ID that uniquely identifies a role definition."]
pub fn get_by_enrollment_account(
&self,
billing_account_name: impl Into<String>,
enrollment_account_name: impl Into<String>,
billing_role_definition_name: impl Into<String>,
) -> get_by_enrollment_account::RequestBuilder {
get_by_enrollment_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
enrollment_account_name: enrollment_account_name.into(),
billing_role_definition_name: billing_role_definition_name.into(),
}
}
#[doc = "Lists the role definitions for a billing account. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement, Microsoft Customer Agreement or Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn list_by_billing_account(&self, billing_account_name: impl Into<String>) -> list_by_billing_account::RequestBuilder {
list_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
}
}
#[doc = "Lists the role definitions for an invoice section. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement or Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
pub fn list_by_invoice_section(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
) -> list_by_invoice_section::RequestBuilder {
list_by_invoice_section::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
}
}
#[doc = "Lists the role definitions for a billing profile. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement or Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn list_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
) -> list_by_billing_profile::RequestBuilder {
list_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
}
}
#[doc = "Lists the role definitions for a department. The operation is supported only for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `department_name`: The ID that uniquely identifies a department."]
pub fn list_by_department(
&self,
billing_account_name: impl Into<String>,
department_name: impl Into<String>,
) -> list_by_department::RequestBuilder {
list_by_department::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
department_name: department_name.into(),
}
}
#[doc = "Lists the role definitions for a enrollmentAccount. The operation is supported only for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `enrollment_account_name`: The ID that uniquely identifies an enrollment account."]
pub fn list_by_enrollment_account(
&self,
billing_account_name: impl Into<String>,
enrollment_account_name: impl Into<String>,
) -> list_by_enrollment_account::RequestBuilder {
list_by_enrollment_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
enrollment_account_name: enrollment_account_name.into(),
}
}
}
pub mod get_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleDefinition> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleDefinition = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_role_definition_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingRoleDefinitions/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_role_definition_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleDefinition>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_by_invoice_section {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleDefinition> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleDefinition = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) billing_role_definition_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/billingRoleDefinitions/{}" , this . client . endpoint () , & this . billing_account_name , & this . billing_profile_name , & this . invoice_section_name , & this . billing_role_definition_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleDefinition>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleDefinition> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleDefinition = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) billing_role_definition_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/billingRoleDefinitions/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.billing_role_definition_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleDefinition>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_by_department {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleDefinition> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleDefinition = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) department_name: String,
pub(crate) billing_role_definition_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/departments/{}/billingRoleDefinitions/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.department_name,
&this.billing_role_definition_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleDefinition>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_by_enrollment_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleDefinition> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleDefinition = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) enrollment_account_name: String,
pub(crate) billing_role_definition_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/enrollmentAccounts/{}/billingRoleDefinitions/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.enrollment_account_name,
&this.billing_role_definition_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleDefinition>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleDefinitionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleDefinitionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BillingRoleDefinitionListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingRoleDefinitions",
this.client.endpoint(),
&this.billing_account_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_invoice_section {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleDefinitionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleDefinitionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/billingRoleDefinitions" , this . client . endpoint () , & this . billing_account_name , & this . billing_profile_name , & this . invoice_section_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleDefinitionListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleDefinitionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleDefinitionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/billingRoleDefinitions",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleDefinitionListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_department {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleDefinitionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleDefinitionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) department_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BillingRoleDefinitionListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/departments/{}/billingRoleDefinitions",
this.client.endpoint(),
&this.billing_account_name,
&this.department_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_enrollment_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleDefinitionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleDefinitionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) enrollment_account_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BillingRoleDefinitionListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/enrollmentAccounts/{}/billingRoleDefinitions",
this.client.endpoint(),
&this.billing_account_name,
&this.enrollment_account_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod billing_role_assignments {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Gets a role assignment for the caller on a billing account. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement, Microsoft Customer Agreement or Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
pub fn get_by_billing_account(
&self,
billing_account_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
) -> get_by_billing_account::RequestBuilder {
get_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
}
}
#[doc = "Deletes a role assignment for the caller on a billing account. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement or Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
pub fn delete_by_billing_account(
&self,
billing_account_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
) -> delete_by_billing_account::RequestBuilder {
delete_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
}
}
#[doc = "Gets a role assignment for the caller on an invoice section. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
pub fn get_by_invoice_section(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
) -> get_by_invoice_section::RequestBuilder {
get_by_invoice_section::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
}
}
#[doc = "Deletes a role assignment for the caller on an invoice section. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
pub fn delete_by_invoice_section(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
) -> delete_by_invoice_section::RequestBuilder {
delete_by_invoice_section::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
}
}
#[doc = "Gets a role assignment for the caller on a billing profile. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement or Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
pub fn get_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
) -> get_by_billing_profile::RequestBuilder {
get_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
}
}
#[doc = "Deletes a role assignment for the caller on a billing profile. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement or Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
pub fn delete_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
) -> delete_by_billing_profile::RequestBuilder {
delete_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
}
}
#[doc = "Gets a role assignment for the caller on a department. The operation is supported only for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `department_name`: The ID that uniquely identifies a department."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
pub fn get_by_department(
&self,
billing_account_name: impl Into<String>,
department_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
) -> get_by_department::RequestBuilder {
get_by_department::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
department_name: department_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
}
}
#[doc = "Deletes a role assignment for the caller on a department. The operation is supported only for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `department_name`: The ID that uniquely identifies a department."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
pub fn delete_by_department(
&self,
billing_account_name: impl Into<String>,
department_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
) -> delete_by_department::RequestBuilder {
delete_by_department::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
department_name: department_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
}
}
#[doc = "Gets a role assignment for the caller on a enrollment Account. The operation is supported only for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `enrollment_account_name`: The ID that uniquely identifies an enrollment account."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
pub fn get_by_enrollment_account(
&self,
billing_account_name: impl Into<String>,
enrollment_account_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
) -> get_by_enrollment_account::RequestBuilder {
get_by_enrollment_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
enrollment_account_name: enrollment_account_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
}
}
#[doc = "Deletes a role assignment for the caller on a enrollment Account. The operation is supported only for billing accounts with agreement type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `enrollment_account_name`: The ID that uniquely identifies an enrollment account."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
pub fn delete_by_enrollment_account(
&self,
billing_account_name: impl Into<String>,
enrollment_account_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
) -> delete_by_enrollment_account::RequestBuilder {
delete_by_enrollment_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
enrollment_account_name: enrollment_account_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
}
}
#[doc = "Lists the role assignments for the caller on a billing account. The operation is supported for billing accounts with agreement type Microsoft Partner Agreement, Microsoft Customer Agreement or Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn list_by_billing_account(&self, billing_account_name: impl Into<String>) -> list_by_billing_account::RequestBuilder {
list_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
}
}
#[doc = "Adds a role assignment on a billing account. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `parameters`: Request parameters that are provided to the create billing role assignment operation."]
pub fn add_by_billing_account(
&self,
billing_account_name: impl Into<String>,
parameters: impl Into<models::BillingRoleAssignmentPayload>,
) -> add_by_billing_account::RequestBuilder {
add_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Lists the role assignments for the caller on an invoice section. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
pub fn list_by_invoice_section(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
) -> list_by_invoice_section::RequestBuilder {
list_by_invoice_section::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
}
}
#[doc = "Adds a role assignment on an invoice section. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `invoice_section_name`: The ID that uniquely identifies an invoice section."]
#[doc = "* `parameters`: Request parameters that are provided to the create billing role assignment operation."]
pub fn add_by_invoice_section(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
invoice_section_name: impl Into<String>,
parameters: impl Into<models::BillingRoleAssignmentPayload>,
) -> add_by_invoice_section::RequestBuilder {
add_by_invoice_section::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
invoice_section_name: invoice_section_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Lists the role assignments for the caller on a billing profile. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
pub fn list_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
) -> list_by_billing_profile::RequestBuilder {
list_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
}
}
#[doc = "Adds a role assignment on a billing profile. The operation is supported for billing accounts with agreement type Microsoft Customer Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_profile_name`: The ID that uniquely identifies a billing profile."]
#[doc = "* `parameters`: Request parameters that are provided to the create billing role assignment operation."]
pub fn add_by_billing_profile(
&self,
billing_account_name: impl Into<String>,
billing_profile_name: impl Into<String>,
parameters: impl Into<models::BillingRoleAssignmentPayload>,
) -> add_by_billing_profile::RequestBuilder {
add_by_billing_profile::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_profile_name: billing_profile_name.into(),
parameters: parameters.into(),
}
}
#[doc = "Lists the role assignments for the caller on a billing profile. The operation is supported for billing accounts of type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `department_name`: The ID that uniquely identifies a department."]
pub fn list_by_department(
&self,
billing_account_name: impl Into<String>,
department_name: impl Into<String>,
) -> list_by_department::RequestBuilder {
list_by_department::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
department_name: department_name.into(),
}
}
#[doc = "Lists the role assignments for the caller on a billing profile. The operation is supported for billing accounts of type Enterprise Agreement."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `enrollment_account_name`: The ID that uniquely identifies an enrollment account."]
pub fn list_by_enrollment_account(
&self,
billing_account_name: impl Into<String>,
enrollment_account_name: impl Into<String>,
) -> list_by_enrollment_account::RequestBuilder {
list_by_enrollment_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
enrollment_account_name: enrollment_account_name.into(),
}
}
}
pub mod get_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_role_assignment_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingRoleAssignments/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_role_assignment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_role_assignment_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingRoleAssignments/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_role_assignment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_by_invoice_section {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) billing_role_assignment_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/billingRoleAssignments/{}" , this . client . endpoint () , & this . billing_account_name , & this . billing_profile_name , & this . invoice_section_name , & this . billing_role_assignment_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_by_invoice_section {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) billing_role_assignment_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/billingRoleAssignments/{}" , this . client . endpoint () , & this . billing_account_name , & this . billing_profile_name , & this . invoice_section_name , & this . billing_role_assignment_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) billing_role_assignment_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/billingRoleAssignments/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.billing_role_assignment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) billing_role_assignment_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/billingRoleAssignments/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name,
&this.billing_role_assignment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_by_department {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) department_name: String,
pub(crate) billing_role_assignment_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/departments/{}/billingRoleAssignments/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.department_name,
&this.billing_role_assignment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_by_department {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) department_name: String,
pub(crate) billing_role_assignment_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/departments/{}/billingRoleAssignments/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.department_name,
&this.billing_role_assignment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_by_enrollment_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) enrollment_account_name: String,
pub(crate) billing_role_assignment_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/enrollmentAccounts/{}/billingRoleAssignments/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.enrollment_account_name,
&this.billing_role_assignment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_by_enrollment_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) enrollment_account_name: String,
pub(crate) billing_role_assignment_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/enrollmentAccounts/{}/billingRoleAssignments/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.enrollment_account_name,
&this.billing_role_assignment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignmentListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignmentListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BillingRoleAssignmentListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingRoleAssignments",
this.client.endpoint(),
&this.billing_account_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod add_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignmentListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignmentListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) parameters: models::BillingRoleAssignmentPayload,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/createBillingRoleAssignment",
this.client.endpoint(),
&this.billing_account_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignmentListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_invoice_section {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignmentListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignmentListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/billingRoleAssignments" , this . client . endpoint () , & this . billing_account_name , & this . billing_profile_name , & this . invoice_section_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignmentListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod add_by_invoice_section {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignmentListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignmentListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) invoice_section_name: String,
pub(crate) parameters: models::BillingRoleAssignmentPayload,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/invoiceSections/{}/createBillingRoleAssignment" , this . client . endpoint () , & this . billing_account_name , & this . billing_profile_name , & this . invoice_section_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignmentListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignmentListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignmentListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/billingRoleAssignments",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignmentListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod add_by_billing_profile {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignmentListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignmentListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_profile_name: String,
pub(crate) parameters: models::BillingRoleAssignmentPayload,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingProfiles/{}/createBillingRoleAssignment",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_profile_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignmentListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_department {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignmentListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignmentListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) department_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BillingRoleAssignmentListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/departments/{}/billingRoleAssignments",
this.client.endpoint(),
&this.billing_account_name,
&this.department_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_enrollment_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignmentListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignmentListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) enrollment_account_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BillingRoleAssignmentListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/enrollmentAccounts/{}/billingRoleAssignments",
this.client.endpoint(),
&this.billing_account_name,
&this.enrollment_account_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod role_assignments {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Create or update a billing role assignment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
#[doc = "* `parameters`: The new or updated billing role assignment."]
pub fn put(
&self,
billing_account_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
parameters: impl Into<models::BillingRoleAssignment>,
) -> put::RequestBuilder {
put::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
parameters: parameters.into(),
}
}
}
pub mod put {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) billing_role_assignment_name: String,
pub(crate) parameters: models::BillingRoleAssignment,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/billingRoleAssignments/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.billing_role_assignment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod enrollment_department_role_assignments {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Create or update a billing role assignment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `department_name`: The ID that uniquely identifies a department."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
#[doc = "* `parameters`: The new or updated billing role assignment."]
pub fn put(
&self,
billing_account_name: impl Into<String>,
department_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
parameters: impl Into<models::BillingRoleAssignment>,
) -> put::RequestBuilder {
put::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
department_name: department_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
parameters: parameters.into(),
}
}
}
pub mod put {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) department_name: String,
pub(crate) billing_role_assignment_name: String,
pub(crate) parameters: models::BillingRoleAssignment,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/departments/{}/billingRoleAssignments/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.department_name,
&this.billing_role_assignment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod enrollment_account_role_assignments {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Create or update a billing role assignment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `enrollment_account_name`: The ID that uniquely identifies an enrollment account."]
#[doc = "* `billing_role_assignment_name`: The ID that uniquely identifies a role assignment."]
#[doc = "* `parameters`: The new or updated billing role assignment."]
pub fn put(
&self,
billing_account_name: impl Into<String>,
enrollment_account_name: impl Into<String>,
billing_role_assignment_name: impl Into<String>,
parameters: impl Into<models::BillingRoleAssignment>,
) -> put::RequestBuilder {
put::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
enrollment_account_name: enrollment_account_name.into(),
billing_role_assignment_name: billing_role_assignment_name.into(),
parameters: parameters.into(),
}
}
}
pub mod put {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingRoleAssignment> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingRoleAssignment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) enrollment_account_name: String,
pub(crate) billing_role_assignment_name: String,
pub(crate) parameters: models::BillingRoleAssignment,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/enrollmentAccounts/{}/billingRoleAssignments/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.enrollment_account_name,
&this.billing_role_assignment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BillingRoleAssignment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod agreements {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Lists the agreements for a billing account."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
pub fn list_by_billing_account(&self, billing_account_name: impl Into<String>) -> list_by_billing_account::RequestBuilder {
list_by_billing_account::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
expand: None,
}
}
#[doc = "Gets an agreement by ID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `billing_account_name`: The ID that uniquely identifies a billing account."]
#[doc = "* `agreement_name`: The ID that uniquely identifies an agreement."]
pub fn get(&self, billing_account_name: impl Into<String>, agreement_name: impl Into<String>) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
billing_account_name: billing_account_name.into(),
agreement_name: agreement_name.into(),
expand: None,
}
}
}
pub mod list_by_billing_account {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AgreementListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::AgreementListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) expand: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to expand the participants."]
pub fn expand(mut self, expand: impl Into<String>) -> Self {
self.expand = Some(expand.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/agreements",
this.client.endpoint(),
&this.billing_account_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(expand) = &this.expand {
req.url_mut().query_pairs_mut().append_pair("$expand", expand);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AgreementListResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Agreement> {
let bytes = self.0.into_body().collect().await?;
let body: models::Agreement = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) billing_account_name: String,
pub(crate) agreement_name: String,
pub(crate) expand: Option<String>,
}
impl RequestBuilder {
#[doc = "May be used to expand the participants."]
pub fn expand(mut self, expand: impl Into<String>) -> Self {
self.expand = Some(expand.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Billing/billingAccounts/{}/agreements/{}",
this.client.endpoint(),
&this.billing_account_name,
&this.agreement_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2019-10-01-preview");
if let Some(expand) = &this.expand {
req.url_mut().query_pairs_mut().append_pair("$expand", expand);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Agreement>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}