#![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 collection_client(&self) -> collection::Client {
collection::Client(self.clone())
}
pub fn discovery_client(&self) -> discovery::Client {
discovery::Client(self.clone())
}
pub fn entity_client(&self) -> entity::Client {
entity::Client(self.clone())
}
pub fn glossary_client(&self) -> glossary::Client {
glossary::Client(self.clone())
}
pub fn lineage_client(&self) -> lineage::Client {
lineage::Client(self.clone())
}
pub fn relationship_client(&self) -> relationship::Client {
relationship::Client(self.clone())
}
pub fn types_client(&self) -> types::Client {
types::Client(self.clone())
}
}
pub mod entity {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Create or update an entity in Atlas.\nExisting entity is matched using its unique guid if supplied or by its unique attributes eg: qualifiedName.\nMap and array of collections are not well supported. E.g., array<array<int>>, array<map<string, int>>."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `entity`: Atlas entity with extended information."]
pub fn create_or_update(&self, entity: impl Into<models::AtlasEntityWithExtInfo>) -> create_or_update::RequestBuilder {
create_or_update::RequestBuilder {
client: self.0.clone(),
entity: entity.into(),
}
}
#[doc = "List entities in bulk identified by its GUIDs."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: An array of GUIDs of entities to list."]
pub fn list_by_guids(&self, guid: Vec<String>) -> list_by_guids::RequestBuilder {
list_by_guids::RequestBuilder {
client: self.0.clone(),
guid,
min_ext_info: None,
ignore_relationships: None,
exclude_relationship_types: Vec::new(),
}
}
#[doc = "Create or update entities in Atlas in bulk.\nExisting entity is matched using its unique guid if supplied or by its unique attributes eg: qualifiedName.\nMap and array of collections are not well supported. E.g., array<array<int>>, array<map<string, int>>."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `entities`: An array of entities to create or update."]
pub fn create_or_update_entities(
&self,
entities: impl Into<models::AtlasEntitiesWithExtInfo>,
) -> create_or_update_entities::RequestBuilder {
create_or_update_entities::RequestBuilder {
client: self.0.clone(),
entities: entities.into(),
}
}
#[doc = "Delete a list of entities in bulk identified by their GUIDs or unique attributes."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: An array of GUIDs of entities to delete."]
pub fn delete_by_guids(&self, guid: Vec<String>) -> delete_by_guids::RequestBuilder {
delete_by_guids::RequestBuilder {
client: self.0.clone(),
guid,
}
}
#[doc = "Associate a classification to multiple entities in bulk."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `request`: The request to associate a classification to multiple entities."]
pub fn add_classification(&self, request: impl Into<models::ClassificationAssociateRequest>) -> add_classification::RequestBuilder {
add_classification::RequestBuilder {
client: self.0.clone(),
request: request.into(),
}
}
#[doc = "Get complete definition of an entity given its GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
pub fn get_by_guid(&self, guid: impl Into<String>) -> get_by_guid::RequestBuilder {
get_by_guid::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
min_ext_info: None,
ignore_relationships: None,
}
}
#[doc = "Update entity partially - create or update entity attribute identified by its GUID.\nSupports only primitive attribute type and entity references.\nIt does not support updating complex types like arrays, and maps.\nNull updates are not possible."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
#[doc = "* `name`: The name of the attribute."]
#[doc = "* `body`: The value of the attribute."]
pub fn partial_update_entity_attribute_by_guid(
&self,
guid: impl Into<String>,
name: impl Into<String>,
body: impl Into<serde_json::Value>,
) -> partial_update_entity_attribute_by_guid::RequestBuilder {
partial_update_entity_attribute_by_guid::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
name: name.into(),
body: body.into(),
}
}
#[doc = "Delete an entity identified by its GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
pub fn delete_by_guid(&self, guid: impl Into<String>) -> delete_by_guid::RequestBuilder {
delete_by_guid::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
}
}
#[doc = "List classifications for a given entity represented by a GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
#[doc = "* `classification_name`: The name of the classification."]
pub fn get_classification(
&self,
guid: impl Into<String>,
classification_name: impl Into<String>,
) -> get_classification::RequestBuilder {
get_classification::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
classification_name: classification_name.into(),
}
}
#[doc = "Delete a given classification from an existing entity represented by a GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
#[doc = "* `classification_name`: The name of the classification."]
pub fn delete_classification(
&self,
guid: impl Into<String>,
classification_name: impl Into<String>,
) -> delete_classification::RequestBuilder {
delete_classification::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
classification_name: classification_name.into(),
}
}
#[doc = "List classifications for a given entity represented by a GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
pub fn get_classifications(&self, guid: impl Into<String>) -> get_classifications::RequestBuilder {
get_classifications::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
}
}
#[doc = "Add classifications to an existing entity represented by a GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
#[doc = "* `classifications`: An array of classifications to be added."]
pub fn add_classifications(
&self,
guid: impl Into<String>,
classifications: Vec<models::AtlasClassification>,
) -> add_classifications::RequestBuilder {
add_classifications::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
classifications,
}
}
#[doc = "Update classifications to an existing entity represented by a guid."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
#[doc = "* `classifications`: An array of classifications to be updated."]
pub fn update_classifications(
&self,
guid: impl Into<String>,
classifications: Vec<models::AtlasClassification>,
) -> update_classifications::RequestBuilder {
update_classifications::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
classifications,
}
}
#[doc = "Get complete definition of an entity given its type and unique attribute.\nIn addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format:\nattr:\\<attrName>=<attrValue>. \nNOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName.\nThe REST request would look something like this:\nGET /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `type_name`: The name of the type."]
pub fn get_by_unique_attributes(&self, type_name: impl Into<String>) -> get_by_unique_attributes::RequestBuilder {
get_by_unique_attributes::RequestBuilder {
client: self.0.clone(),
type_name: type_name.into(),
min_ext_info: None,
ignore_relationships: None,
attr_qualified_name: None,
}
}
#[doc = "Update entity partially - Allow a subset of attributes to be updated on\nan entity which is identified by its type and unique attribute eg: Referenceable.qualifiedName.\nNull updates are not possible.\nIn addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format:\nattr:<attrName>=<attrValue>.\nNOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName.\nThe REST request would look something like this:\nPUT /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `type_name`: The name of the type."]
#[doc = "* `atlas_entity_with_ext_info`: Atlas entity with extended information."]
pub fn partial_update_entity_by_unique_attributes(
&self,
type_name: impl Into<String>,
atlas_entity_with_ext_info: impl Into<models::AtlasEntityWithExtInfo>,
) -> partial_update_entity_by_unique_attributes::RequestBuilder {
partial_update_entity_by_unique_attributes::RequestBuilder {
client: self.0.clone(),
type_name: type_name.into(),
atlas_entity_with_ext_info: atlas_entity_with_ext_info.into(),
attr_qualified_name: None,
}
}
#[doc = "Delete an entity identified by its type and unique attributes.\nIn addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format:\nattr:\\<attrName>=\\<attrValue>.\nNOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName.\nThe REST request would look something like this:\nDELETE /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `type_name`: The name of the type."]
pub fn delete_by_unique_attribute(&self, type_name: impl Into<String>) -> delete_by_unique_attribute::RequestBuilder {
delete_by_unique_attribute::RequestBuilder {
client: self.0.clone(),
type_name: type_name.into(),
attr_qualified_name: None,
}
}
#[doc = "Delete a given classification from an entity identified by its type and unique attributes."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `type_name`: The name of the type."]
#[doc = "* `classification_name`: The name of the classification."]
pub fn delete_classification_by_unique_attribute(
&self,
type_name: impl Into<String>,
classification_name: impl Into<String>,
) -> delete_classification_by_unique_attribute::RequestBuilder {
delete_classification_by_unique_attribute::RequestBuilder {
client: self.0.clone(),
type_name: type_name.into(),
classification_name: classification_name.into(),
attr_qualified_name: None,
}
}
#[doc = "Add classification to the entity identified by its type and unique attributes."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `type_name`: The name of the type."]
#[doc = "* `atlas_classification_array`: An array of classification to be added."]
pub fn add_classifications_by_unique_attribute(
&self,
type_name: impl Into<String>,
atlas_classification_array: Vec<models::AtlasClassification>,
) -> add_classifications_by_unique_attribute::RequestBuilder {
add_classifications_by_unique_attribute::RequestBuilder {
client: self.0.clone(),
type_name: type_name.into(),
atlas_classification_array,
attr_qualified_name: None,
}
}
#[doc = "Update classification on an entity identified by its type and unique attributes."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `type_name`: The name of the type."]
#[doc = "* `atlas_classification_array`: An array of classification to be updated."]
pub fn update_classifications_by_unique_attribute(
&self,
type_name: impl Into<String>,
atlas_classification_array: Vec<models::AtlasClassification>,
) -> update_classifications_by_unique_attribute::RequestBuilder {
update_classifications_by_unique_attribute::RequestBuilder {
client: self.0.clone(),
type_name: type_name.into(),
atlas_classification_array,
attr_qualified_name: None,
}
}
#[doc = "Set classifications on entities in bulk."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `entity_headers`: Atlas entity headers."]
pub fn set_classifications(&self, entity_headers: impl Into<models::AtlasEntityHeaders>) -> set_classifications::RequestBuilder {
set_classifications::RequestBuilder {
client: self.0.clone(),
entity_headers: entity_headers.into(),
}
}
#[doc = "Bulk API to retrieve list of entities identified by its unique attributes.\n\nIn addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format\n\ntypeName=\\<typeName>&attr_1:\\<attrName>=\\<attrValue>&attr_2:\\<attrName>=\\<attrValue>&attr_3:\\<attrName>=\\<attrValue>\n\nNOTE: The attrName should be an unique attribute for the given entity-type\n\nThe REST request would look something like this\n\nGET /v2/entity/bulk/uniqueAttribute/type/hive_db?attr_0:qualifiedName=db1@cl1&attr_2:qualifiedName=db2@cl1"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `type_name`: The name of the type."]
pub fn get_entities_by_unique_attributes(&self, type_name: impl Into<String>) -> get_entities_by_unique_attributes::RequestBuilder {
get_entities_by_unique_attributes::RequestBuilder {
client: self.0.clone(),
type_name: type_name.into(),
min_ext_info: None,
ignore_relationships: None,
attr_n_qualified_name: None,
}
}
#[doc = "Get entity header given its GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
pub fn get_header(&self, guid: impl Into<String>) -> get_header::RequestBuilder {
get_header::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
}
}
#[doc = "Add business metadata to an entity."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
pub fn add_or_update_business_metadata(&self, guid: impl Into<String>) -> add_or_update_business_metadata::RequestBuilder {
add_or_update_business_metadata::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
is_overwrite: None,
body: None,
}
}
#[doc = "Remove business metadata from an entity."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
pub fn delete_business_metadata(&self, guid: impl Into<String>) -> delete_business_metadata::RequestBuilder {
delete_business_metadata::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
body: None,
}
}
#[doc = "Add or update business metadata attributes"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `bm_name`: BusinessMetadata name"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
pub fn add_or_update_business_metadata_attributes(
&self,
bm_name: impl Into<String>,
guid: impl Into<String>,
) -> add_or_update_business_metadata_attributes::RequestBuilder {
add_or_update_business_metadata_attributes::RequestBuilder {
client: self.0.clone(),
bm_name: bm_name.into(),
guid: guid.into(),
body: None,
}
}
#[doc = "Delete business metadata attributes from an entity."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `bm_name`: BusinessMetadata name"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
pub fn delete_business_metadata_attributes(
&self,
bm_name: impl Into<String>,
guid: impl Into<String>,
) -> delete_business_metadata_attributes::RequestBuilder {
delete_business_metadata_attributes::RequestBuilder {
client: self.0.clone(),
bm_name: bm_name.into(),
guid: guid.into(),
body: None,
}
}
#[doc = "Get the sample Template for uploading/creating bulk BusinessMetaData"]
pub fn get_sample_business_metadata_template(&self) -> get_sample_business_metadata_template::RequestBuilder {
get_sample_business_metadata_template::RequestBuilder { client: self.0.clone() }
}
#[doc = "Upload the file for creating Business Metadata in BULK"]
pub fn import_business_metadata(&self) -> import_business_metadata::RequestBuilder {
import_business_metadata::RequestBuilder {
client: self.0.clone(),
uploaded_input_stream: None,
}
}
#[doc = "Set labels to a given entity"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
pub fn set_labels(&self, guid: impl Into<String>) -> set_labels::RequestBuilder {
set_labels::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
body: Vec::new(),
}
}
#[doc = "add given labels to a given entity"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
pub fn add_label(&self, guid: impl Into<String>) -> add_label::RequestBuilder {
add_label::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
body: Vec::new(),
}
}
#[doc = "delete given labels to a given entity"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
pub fn delete_labels(&self, guid: impl Into<String>) -> delete_labels::RequestBuilder {
delete_labels::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
body: Vec::new(),
}
}
#[doc = "Set labels to a given entity identified by its type and unique attributes, if labels is null/empty, existing labels will all be removed. In addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format: attr:<attrName>=<attrValue>. NOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName. The REST request would look something like this: POST /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `type_name`: The name of the type."]
pub fn set_labels_by_unique_attribute(&self, type_name: impl Into<String>) -> set_labels_by_unique_attribute::RequestBuilder {
set_labels_by_unique_attribute::RequestBuilder {
client: self.0.clone(),
type_name: type_name.into(),
attr_qualified_name: None,
body: Vec::new(),
}
}
#[doc = "Add given labels to a given entity identified by its type and unique attributes, if labels is null/empty, no labels will be added. In addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format: attr:<attrName>=<attrValue>. NOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName. The REST request would look something like this: PUT /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `type_name`: The name of the type."]
pub fn add_labels_by_unique_attribute(&self, type_name: impl Into<String>) -> add_labels_by_unique_attribute::RequestBuilder {
add_labels_by_unique_attribute::RequestBuilder {
client: self.0.clone(),
type_name: type_name.into(),
attr_qualified_name: None,
body: Vec::new(),
}
}
#[doc = "Delete given labels to a given entity identified by its type and unique attributes, if labels is null/empty, no labels will be removed. If any labels in labels set are non-existing labels, they will be ignored, only existing labels will be removed. In addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format: attr:<attrName>=<attrValue>. NOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName. The REST request would look something like this: DELETE /v2/entity/uniqueAttribute/type/aType?attr:aTypeAttribute=someValue. "]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `type_name`: The name of the type."]
pub fn delete_labels_by_unique_attribute(&self, type_name: impl Into<String>) -> delete_labels_by_unique_attribute::RequestBuilder {
delete_labels_by_unique_attribute::RequestBuilder {
client: self.0.clone(),
type_name: type_name.into(),
attr_qualified_name: None,
body: Vec::new(),
}
}
}
pub mod create_or_update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::EntityMutationResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::EntityMutationResponse = 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) entity: models::AtlasEntityWithExtInfo,
}
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!("{}/atlas/v2/entity", 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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.entity)?;
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::EntityMutationResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_guids {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasEntitiesWithExtInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasEntitiesWithExtInfo = 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) guid: Vec<String>,
pub(crate) min_ext_info: Option<bool>,
pub(crate) ignore_relationships: Option<bool>,
pub(crate) exclude_relationship_types: Vec<String>,
}
impl RequestBuilder {
#[doc = "Whether to return minimal information for referred entities."]
pub fn min_ext_info(mut self, min_ext_info: bool) -> Self {
self.min_ext_info = Some(min_ext_info);
self
}
#[doc = "Whether to ignore relationship attributes."]
pub fn ignore_relationships(mut self, ignore_relationships: bool) -> Self {
self.ignore_relationships = Some(ignore_relationships);
self
}
#[doc = "An array of the relationship types need to be excluded from the response."]
pub fn exclude_relationship_types(mut self, exclude_relationship_types: Vec<String>) -> Self {
self.exclude_relationship_types = exclude_relationship_types;
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!("{}/atlas/v2/entity/bulk", 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()),
);
let guid = &this.guid;
for value in &this.guid {
req.url_mut().query_pairs_mut().append_pair("guid", &value.to_string());
}
if let Some(min_ext_info) = &this.min_ext_info {
req.url_mut().query_pairs_mut().append_pair("minExtInfo", &min_ext_info.to_string());
}
if let Some(ignore_relationships) = &this.ignore_relationships {
req.url_mut()
.query_pairs_mut()
.append_pair("ignoreRelationships", &ignore_relationships.to_string());
}
let exclude_relationship_types = &this.exclude_relationship_types;
for value in &this.exclude_relationship_types {
req.url_mut()
.query_pairs_mut()
.append_pair("excludeRelationshipTypes", &value.to_string());
}
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::AtlasEntitiesWithExtInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_entities {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::EntityMutationResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::EntityMutationResponse = 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) entities: models::AtlasEntitiesWithExtInfo,
}
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!("{}/atlas/v2/entity/bulk", 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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.entities)?;
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::EntityMutationResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_by_guids {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::EntityMutationResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::EntityMutationResponse = 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) guid: Vec<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!("{}/atlas/v2/entity/bulk", this.client.endpoint(),))?;
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 guid = &this.guid;
for value in &this.guid {
req.url_mut().query_pairs_mut().append_pair("guid", &value.to_string());
}
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::EntityMutationResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod add_classification {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) request: models::ClassificationAssociateRequest,
}
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!("{}/atlas/v2/entity/bulk/classification", 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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_by_guid {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasEntityWithExtInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasEntityWithExtInfo = 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) guid: String,
pub(crate) min_ext_info: Option<bool>,
pub(crate) ignore_relationships: Option<bool>,
}
impl RequestBuilder {
#[doc = "Whether to return minimal information for referred entities."]
pub fn min_ext_info(mut self, min_ext_info: bool) -> Self {
self.min_ext_info = Some(min_ext_info);
self
}
#[doc = "Whether to ignore relationship attributes."]
pub fn ignore_relationships(mut self, ignore_relationships: bool) -> Self {
self.ignore_relationships = Some(ignore_relationships);
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!("{}/atlas/v2/entity/guid/{}", this.client.endpoint(), &this.guid))?;
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()),
);
if let Some(min_ext_info) = &this.min_ext_info {
req.url_mut().query_pairs_mut().append_pair("minExtInfo", &min_ext_info.to_string());
}
if let Some(ignore_relationships) = &this.ignore_relationships {
req.url_mut()
.query_pairs_mut()
.append_pair("ignoreRelationships", &ignore_relationships.to_string());
}
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::AtlasEntityWithExtInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod partial_update_entity_attribute_by_guid {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::EntityMutationResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::EntityMutationResponse = 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) guid: String,
pub(crate) name: String,
pub(crate) body: serde_json::Value,
}
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!("{}/atlas/v2/entity/guid/{}", this.client.endpoint(), &this.guid))?;
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()),
);
let name = &this.name;
req.url_mut().query_pairs_mut().append_pair("name", name);
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::EntityMutationResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_by_guid {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::EntityMutationResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::EntityMutationResponse = 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) guid: 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!("{}/atlas/v2/entity/guid/{}", this.client.endpoint(), &this.guid))?;
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::EntityMutationResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_classification {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasClassification> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasClassification = 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) guid: String,
pub(crate) classification_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!(
"{}/atlas/v2/entity/guid/{}/classification/{}",
this.client.endpoint(),
&this.guid,
&this.classification_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::AtlasClassification>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_classification {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) guid: String,
pub(crate) classification_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!(
"{}/atlas/v2/entity/guid/{}/classification/{}",
this.client.endpoint(),
&this.guid,
&this.classification_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?))
}
})
}
}
}
pub mod get_classifications {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasClassifications> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasClassifications = 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) guid: 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!(
"{}/atlas/v2/entity/guid/{}/classifications",
this.client.endpoint(),
&this.guid
))?;
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::AtlasClassifications>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod add_classifications {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) guid: String,
pub(crate) classifications: Vec<models::AtlasClassification>,
}
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!(
"{}/atlas/v2/entity/guid/{}/classifications",
this.client.endpoint(),
&this.guid
))?;
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.classifications)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod update_classifications {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) guid: String,
pub(crate) classifications: Vec<models::AtlasClassification>,
}
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!(
"{}/atlas/v2/entity/guid/{}/classifications",
this.client.endpoint(),
&this.guid
))?;
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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.classifications)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_by_unique_attributes {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasEntityWithExtInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasEntityWithExtInfo = 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) type_name: String,
pub(crate) min_ext_info: Option<bool>,
pub(crate) ignore_relationships: Option<bool>,
pub(crate) attr_qualified_name: Option<String>,
}
impl RequestBuilder {
#[doc = "Whether to return minimal information for referred entities."]
pub fn min_ext_info(mut self, min_ext_info: bool) -> Self {
self.min_ext_info = Some(min_ext_info);
self
}
#[doc = "Whether to ignore relationship attributes."]
pub fn ignore_relationships(mut self, ignore_relationships: bool) -> Self {
self.ignore_relationships = Some(ignore_relationships);
self
}
#[doc = "The qualified name of the entity."]
pub fn attr_qualified_name(mut self, attr_qualified_name: impl Into<String>) -> Self {
self.attr_qualified_name = Some(attr_qualified_name.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!(
"{}/atlas/v2/entity/uniqueAttribute/type/{}",
this.client.endpoint(),
&this.type_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()),
);
if let Some(min_ext_info) = &this.min_ext_info {
req.url_mut().query_pairs_mut().append_pair("minExtInfo", &min_ext_info.to_string());
}
if let Some(ignore_relationships) = &this.ignore_relationships {
req.url_mut()
.query_pairs_mut()
.append_pair("ignoreRelationships", &ignore_relationships.to_string());
}
if let Some(attr_qualified_name) = &this.attr_qualified_name {
req.url_mut()
.query_pairs_mut()
.append_pair("attr:qualifiedName", attr_qualified_name);
}
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::AtlasEntityWithExtInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod partial_update_entity_by_unique_attributes {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::EntityMutationResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::EntityMutationResponse = 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) type_name: String,
pub(crate) atlas_entity_with_ext_info: models::AtlasEntityWithExtInfo,
pub(crate) attr_qualified_name: Option<String>,
}
impl RequestBuilder {
#[doc = "The qualified name of the entity."]
pub fn attr_qualified_name(mut self, attr_qualified_name: impl Into<String>) -> Self {
self.attr_qualified_name = Some(attr_qualified_name.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!(
"{}/atlas/v2/entity/uniqueAttribute/type/{}",
this.client.endpoint(),
&this.type_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()),
);
if let Some(attr_qualified_name) = &this.attr_qualified_name {
req.url_mut()
.query_pairs_mut()
.append_pair("attr:qualifiedName", attr_qualified_name);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.atlas_entity_with_ext_info)?;
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::EntityMutationResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_by_unique_attribute {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::EntityMutationResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::EntityMutationResponse = 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) type_name: String,
pub(crate) attr_qualified_name: Option<String>,
}
impl RequestBuilder {
#[doc = "The qualified name of the entity."]
pub fn attr_qualified_name(mut self, attr_qualified_name: impl Into<String>) -> Self {
self.attr_qualified_name = Some(attr_qualified_name.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!(
"{}/atlas/v2/entity/uniqueAttribute/type/{}",
this.client.endpoint(),
&this.type_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()),
);
if let Some(attr_qualified_name) = &this.attr_qualified_name {
req.url_mut()
.query_pairs_mut()
.append_pair("attr:qualifiedName", attr_qualified_name);
}
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::EntityMutationResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_classification_by_unique_attribute {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) type_name: String,
pub(crate) classification_name: String,
pub(crate) attr_qualified_name: Option<String>,
}
impl RequestBuilder {
#[doc = "The qualified name of the entity."]
pub fn attr_qualified_name(mut self, attr_qualified_name: impl Into<String>) -> Self {
self.attr_qualified_name = Some(attr_qualified_name.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!(
"{}/atlas/v2/entity/uniqueAttribute/type/{}/classification/{}",
this.client.endpoint(),
&this.type_name,
&this.classification_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()),
);
if let Some(attr_qualified_name) = &this.attr_qualified_name {
req.url_mut()
.query_pairs_mut()
.append_pair("attr:qualifiedName", attr_qualified_name);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod add_classifications_by_unique_attribute {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) type_name: String,
pub(crate) atlas_classification_array: Vec<models::AtlasClassification>,
pub(crate) attr_qualified_name: Option<String>,
}
impl RequestBuilder {
#[doc = "The qualified name of the entity."]
pub fn attr_qualified_name(mut self, attr_qualified_name: impl Into<String>) -> Self {
self.attr_qualified_name = Some(attr_qualified_name.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!(
"{}/atlas/v2/entity/uniqueAttribute/type/{}/classifications",
this.client.endpoint(),
&this.type_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()),
);
if let Some(attr_qualified_name) = &this.attr_qualified_name {
req.url_mut()
.query_pairs_mut()
.append_pair("attr:qualifiedName", attr_qualified_name);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.atlas_classification_array)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod update_classifications_by_unique_attribute {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) type_name: String,
pub(crate) atlas_classification_array: Vec<models::AtlasClassification>,
pub(crate) attr_qualified_name: Option<String>,
}
impl RequestBuilder {
#[doc = "The qualified name of the entity."]
pub fn attr_qualified_name(mut self, attr_qualified_name: impl Into<String>) -> Self {
self.attr_qualified_name = Some(attr_qualified_name.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!(
"{}/atlas/v2/entity/uniqueAttribute/type/{}/classifications",
this.client.endpoint(),
&this.type_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()),
);
if let Some(attr_qualified_name) = &this.attr_qualified_name {
req.url_mut()
.query_pairs_mut()
.append_pair("attr:qualifiedName", attr_qualified_name);
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.atlas_classification_array)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod set_classifications {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<String>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<String> = 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) entity_headers: models::AtlasEntityHeaders,
}
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!("{}/atlas/v2/entity/bulk/setClassifications", 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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.entity_headers)?;
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<Vec<String>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_entities_by_unique_attributes {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasEntitiesWithExtInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasEntitiesWithExtInfo = 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) type_name: String,
pub(crate) min_ext_info: Option<bool>,
pub(crate) ignore_relationships: Option<bool>,
pub(crate) attr_n_qualified_name: Option<String>,
}
impl RequestBuilder {
#[doc = "Whether to return minimal information for referred entities."]
pub fn min_ext_info(mut self, min_ext_info: bool) -> Self {
self.min_ext_info = Some(min_ext_info);
self
}
#[doc = "Whether to ignore relationship attributes."]
pub fn ignore_relationships(mut self, ignore_relationships: bool) -> Self {
self.ignore_relationships = Some(ignore_relationships);
self
}
#[doc = "Qualified name of an entity. E.g. to find 2 entities you can set attrs_0:qualifiedName=db1@cl1&attrs_2:qualifiedName=db2@cl1"]
pub fn attr_n_qualified_name(mut self, attr_n_qualified_name: impl Into<String>) -> Self {
self.attr_n_qualified_name = Some(attr_n_qualified_name.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!(
"{}/atlas/v2/entity/bulk/uniqueAttribute/type/{}",
this.client.endpoint(),
&this.type_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()),
);
if let Some(min_ext_info) = &this.min_ext_info {
req.url_mut().query_pairs_mut().append_pair("minExtInfo", &min_ext_info.to_string());
}
if let Some(ignore_relationships) = &this.ignore_relationships {
req.url_mut()
.query_pairs_mut()
.append_pair("ignoreRelationships", &ignore_relationships.to_string());
}
if let Some(attr_n_qualified_name) = &this.attr_n_qualified_name {
req.url_mut()
.query_pairs_mut()
.append_pair("attr_N:qualifiedName", attr_n_qualified_name);
}
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::AtlasEntitiesWithExtInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_header {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasEntityHeader> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasEntityHeader = 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) guid: 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!("{}/atlas/v2/entity/guid/{}/header", this.client.endpoint(), &this.guid))?;
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::AtlasEntityHeader>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod add_or_update_business_metadata {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) guid: String,
pub(crate) is_overwrite: Option<bool>,
pub(crate) body: Option<serde_json::Value>,
}
impl RequestBuilder {
#[doc = "Whether to overwrite the existing business metadata on the entity or not, default is false."]
pub fn is_overwrite(mut self, is_overwrite: bool) -> Self {
self.is_overwrite = Some(is_overwrite);
self
}
#[doc = "Business Metadata"]
pub fn body(mut self, body: impl Into<serde_json::Value>) -> Self {
self.body = Some(body.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!(
"{}/atlas/v2/entity/guid/{}/businessmetadata",
this.client.endpoint(),
&this.guid
))?;
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()),
);
if let Some(is_overwrite) = &this.is_overwrite {
req.url_mut()
.query_pairs_mut()
.append_pair("isOverwrite", &is_overwrite.to_string());
}
let req_body = if let Some(body) = &this.body {
req.insert_header("content-type", "application/json");
azure_core::to_json(body)?
} else {
azure_core::EMPTY_BODY
};
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod delete_business_metadata {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) guid: String,
pub(crate) body: Option<serde_json::Value>,
}
impl RequestBuilder {
#[doc = "BusinessMetadata"]
pub fn body(mut self, body: impl Into<serde_json::Value>) -> Self {
self.body = Some(body.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!(
"{}/atlas/v2/entity/guid/{}/businessmetadata",
this.client.endpoint(),
&this.guid
))?;
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 = if let Some(body) = &this.body {
req.insert_header("content-type", "application/json");
azure_core::to_json(body)?
} else {
azure_core::EMPTY_BODY
};
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod add_or_update_business_metadata_attributes {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) bm_name: String,
pub(crate) guid: String,
pub(crate) body: Option<serde_json::Value>,
}
impl RequestBuilder {
#[doc = "BusinessMetadataAttributes"]
pub fn body(mut self, body: impl Into<serde_json::Value>) -> Self {
self.body = Some(body.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!(
"{}/atlas/v2/entity/guid/{}/businessmetadata/{}",
this.client.endpoint(),
&this.guid,
&this.bm_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 = if let Some(body) = &this.body {
req.insert_header("content-type", "application/json");
azure_core::to_json(body)?
} else {
azure_core::EMPTY_BODY
};
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod delete_business_metadata_attributes {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) bm_name: String,
pub(crate) guid: String,
pub(crate) body: Option<serde_json::Value>,
}
impl RequestBuilder {
#[doc = "BusinessMetadataAttributes"]
pub fn body(mut self, body: impl Into<serde_json::Value>) -> Self {
self.body = Some(body.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!(
"{}/atlas/v2/entity/guid/{}/businessmetadata/{}",
this.client.endpoint(),
&this.guid,
&this.bm_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 = if let Some(body) = &this.body {
req.insert_header("content-type", "application/json");
azure_core::to_json(body)?
} else {
azure_core::EMPTY_BODY
};
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_sample_business_metadata_template {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<bytes::Bytes> {
let bytes = self.0.into_body().collect().await?;
let body = 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 {
#[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!(
"{}/atlas/v2/entity/businessmetadata/import/template",
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()),
);
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<bytes::Bytes>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod import_business_metadata {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BulkImportResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::BulkImportResponse = 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) uploaded_input_stream: Option<bytes::Bytes>,
}
impl RequestBuilder {
#[doc = "InputStream of file"]
pub fn uploaded_input_stream(mut self, uploaded_input_stream: impl Into<bytes::Bytes>) -> Self {
self.uploaded_input_stream = Some(uploaded_input_stream.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!("{}/atlas/v2/entity/businessmetadata/import", 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()),
);
unimplemented!("form data not yet supported");
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::BulkImportResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod set_labels {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) guid: String,
pub(crate) body: Vec<String>,
}
impl RequestBuilder {
#[doc = "set of labels to be set to the entity"]
pub fn body(mut self, body: Vec<String>) -> Self {
self.body = body;
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!("{}/atlas/v2/entity/guid/{}/labels", this.client.endpoint(), &this.guid))?;
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.body)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod add_label {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) guid: String,
pub(crate) body: Vec<String>,
}
impl RequestBuilder {
#[doc = "set of labels to be added"]
pub fn body(mut self, body: Vec<String>) -> Self {
self.body = body;
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!("{}/atlas/v2/entity/guid/{}/labels", this.client.endpoint(), &this.guid))?;
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.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?))
}
})
}
}
}
pub mod delete_labels {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) guid: String,
pub(crate) body: Vec<String>,
}
impl RequestBuilder {
#[doc = "set of labels to be deleted"]
pub fn body(mut self, body: Vec<String>) -> Self {
self.body = body;
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!("{}/atlas/v2/entity/guid/{}/labels", this.client.endpoint(), &this.guid))?;
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.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?))
}
})
}
}
}
pub mod set_labels_by_unique_attribute {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) type_name: String,
pub(crate) attr_qualified_name: Option<String>,
pub(crate) body: Vec<String>,
}
impl RequestBuilder {
#[doc = "The qualified name of the entity"]
pub fn attr_qualified_name(mut self, attr_qualified_name: impl Into<String>) -> Self {
self.attr_qualified_name = Some(attr_qualified_name.into());
self
}
#[doc = "set of labels to be set"]
pub fn body(mut self, body: Vec<String>) -> Self {
self.body = body;
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!(
"{}/atlas/v2/entity/uniqueAttribute/type/{}/labels",
this.client.endpoint(),
&this.type_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()),
);
if let Some(attr_qualified_name) = &this.attr_qualified_name {
req.url_mut()
.query_pairs_mut()
.append_pair("attr:qualifiedName", attr_qualified_name);
}
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?))
}
})
}
}
}
pub mod add_labels_by_unique_attribute {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) type_name: String,
pub(crate) attr_qualified_name: Option<String>,
pub(crate) body: Vec<String>,
}
impl RequestBuilder {
#[doc = "The qualified name of the entity"]
pub fn attr_qualified_name(mut self, attr_qualified_name: impl Into<String>) -> Self {
self.attr_qualified_name = Some(attr_qualified_name.into());
self
}
#[doc = "set of labels to be added"]
pub fn body(mut self, body: Vec<String>) -> Self {
self.body = body;
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!(
"{}/atlas/v2/entity/uniqueAttribute/type/{}/labels",
this.client.endpoint(),
&this.type_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()),
);
if let Some(attr_qualified_name) = &this.attr_qualified_name {
req.url_mut()
.query_pairs_mut()
.append_pair("attr:qualifiedName", attr_qualified_name);
}
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?))
}
})
}
}
}
pub mod delete_labels_by_unique_attribute {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) type_name: String,
pub(crate) attr_qualified_name: Option<String>,
pub(crate) body: Vec<String>,
}
impl RequestBuilder {
#[doc = "The qualified name of the entity"]
pub fn attr_qualified_name(mut self, attr_qualified_name: impl Into<String>) -> Self {
self.attr_qualified_name = Some(attr_qualified_name.into());
self
}
#[doc = "set of labels to be deleted"]
pub fn body(mut self, body: Vec<String>) -> Self {
self.body = body;
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!(
"{}/atlas/v2/entity/uniqueAttribute/type/{}/labels",
this.client.endpoint(),
&this.type_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()),
);
if let Some(attr_qualified_name) = &this.attr_qualified_name {
req.url_mut()
.query_pairs_mut()
.append_pair("attr:qualifiedName", attr_qualified_name);
}
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?))
}
})
}
}
}
}
pub mod glossary {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get all glossaries registered with Atlas."]
pub fn list_glossaries(&self) -> list_glossaries::RequestBuilder {
list_glossaries::RequestBuilder {
client: self.0.clone(),
limit: None,
offset: None,
sort: None,
ignore_terms_and_categories: None,
}
}
#[doc = "Create a glossary."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `atlas_glossary`: Glossary definition, terms & categories can be anchored to a glossary.\nUsing the anchor attribute when creating the Term/Category."]
pub fn create_glossary(&self, atlas_glossary: impl Into<models::AtlasGlossary>) -> create_glossary::RequestBuilder {
create_glossary::RequestBuilder {
client: self.0.clone(),
atlas_glossary: atlas_glossary.into(),
}
}
#[doc = "Create glossary category in bulk."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_category`: An array of glossary category definitions to be created."]
pub fn create_glossary_categories(
&self,
glossary_category: Vec<models::AtlasGlossaryCategory>,
) -> create_glossary_categories::RequestBuilder {
create_glossary_categories::RequestBuilder {
client: self.0.clone(),
glossary_category,
}
}
#[doc = "Create a glossary category."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_category`: The glossary category definition. A category must be anchored to a Glossary when creating.\nOptionally, terms belonging to the category and the hierarchy can also be defined during creation."]
pub fn create_glossary_category(
&self,
glossary_category: impl Into<models::AtlasGlossaryCategory>,
) -> create_glossary_category::RequestBuilder {
create_glossary_category::RequestBuilder {
client: self.0.clone(),
glossary_category: glossary_category.into(),
}
}
#[doc = "Get specific glossary category by its GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `category_guid`: The globally unique identifier of the category."]
pub fn get_glossary_category(&self, category_guid: impl Into<String>) -> get_glossary_category::RequestBuilder {
get_glossary_category::RequestBuilder {
client: self.0.clone(),
category_guid: category_guid.into(),
}
}
#[doc = "Update the given glossary category by its GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `category_guid`: The globally unique identifier of the category."]
#[doc = "* `glossary_category`: The glossary category to be updated."]
pub fn update_glossary_category(
&self,
category_guid: impl Into<String>,
glossary_category: impl Into<models::AtlasGlossaryCategory>,
) -> update_glossary_category::RequestBuilder {
update_glossary_category::RequestBuilder {
client: self.0.clone(),
category_guid: category_guid.into(),
glossary_category: glossary_category.into(),
}
}
#[doc = "Delete a glossary category."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `category_guid`: The globally unique identifier of the category."]
pub fn delete_glossary_category(&self, category_guid: impl Into<String>) -> delete_glossary_category::RequestBuilder {
delete_glossary_category::RequestBuilder {
client: self.0.clone(),
category_guid: category_guid.into(),
}
}
#[doc = "Update the glossary category partially."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `category_guid`: The globally unique identifier of the category."]
#[doc = "* `partial_updates`: A map containing keys as attribute names and values as corresponding attribute values for partial update."]
pub fn partial_update_glossary_category(
&self,
category_guid: impl Into<String>,
partial_updates: impl Into<serde_json::Value>,
) -> partial_update_glossary_category::RequestBuilder {
partial_update_glossary_category::RequestBuilder {
client: self.0.clone(),
category_guid: category_guid.into(),
partial_updates: partial_updates.into(),
}
}
#[doc = "Get all related categories (parent and children). Limit, offset, and sort parameters are currently not being enabled and won't work even they are passed."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `category_guid`: The globally unique identifier of the category."]
pub fn list_related_categories(&self, category_guid: impl Into<String>) -> list_related_categories::RequestBuilder {
list_related_categories::RequestBuilder {
client: self.0.clone(),
category_guid: category_guid.into(),
limit: None,
offset: None,
sort: None,
}
}
#[doc = "Get all terms associated with the specific category."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `category_guid`: The globally unique identifier of the category."]
pub fn list_category_terms(&self, category_guid: impl Into<String>) -> list_category_terms::RequestBuilder {
list_category_terms::RequestBuilder {
client: self.0.clone(),
category_guid: category_guid.into(),
limit: None,
offset: None,
sort: None,
}
}
#[doc = "Create a glossary term."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_term`: The glossary term definition. A term must be anchored to a Glossary at the time of creation.\nOptionally it can be categorized as well."]
pub fn create_glossary_term(&self, glossary_term: impl Into<models::AtlasGlossaryTerm>) -> create_glossary_term::RequestBuilder {
create_glossary_term::RequestBuilder {
client: self.0.clone(),
glossary_term: glossary_term.into(),
include_term_hierarchy: None,
}
}
#[doc = "Get a specific glossary term by its GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `term_guid`: The globally unique identifier for glossary term."]
pub fn get_glossary_term(&self, term_guid: impl Into<String>) -> get_glossary_term::RequestBuilder {
get_glossary_term::RequestBuilder {
client: self.0.clone(),
term_guid: term_guid.into(),
include_term_hierarchy: None,
exclude_relationship_types: Vec::new(),
}
}
#[doc = "Update the given glossary term by its GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `term_guid`: The globally unique identifier for glossary term."]
#[doc = "* `glossary_term`: The glossary term to be updated."]
pub fn update_glossary_term(
&self,
term_guid: impl Into<String>,
glossary_term: impl Into<models::AtlasGlossaryTerm>,
) -> update_glossary_term::RequestBuilder {
update_glossary_term::RequestBuilder {
client: self.0.clone(),
term_guid: term_guid.into(),
glossary_term: glossary_term.into(),
include_term_hierarchy: None,
}
}
#[doc = "Delete a glossary term."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `term_guid`: The globally unique identifier for glossary term."]
pub fn delete_glossary_term(&self, term_guid: impl Into<String>) -> delete_glossary_term::RequestBuilder {
delete_glossary_term::RequestBuilder {
client: self.0.clone(),
term_guid: term_guid.into(),
}
}
#[doc = "Update the glossary term partially."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `term_guid`: The globally unique identifier for glossary term."]
#[doc = "* `partial_updates`: A map containing keys as attribute names and values as corresponding attribute values to be updated."]
pub fn partial_update_glossary_term(
&self,
term_guid: impl Into<String>,
partial_updates: impl Into<serde_json::Value>,
) -> partial_update_glossary_term::RequestBuilder {
partial_update_glossary_term::RequestBuilder {
client: self.0.clone(),
term_guid: term_guid.into(),
partial_updates: partial_updates.into(),
include_term_hierarchy: None,
}
}
#[doc = "Create glossary terms in bulk."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_term`: An array of glossary term definitions to be created in bulk."]
pub fn create_glossary_terms(&self, glossary_term: Vec<models::AtlasGlossaryTerm>) -> create_glossary_terms::RequestBuilder {
create_glossary_terms::RequestBuilder {
client: self.0.clone(),
glossary_term,
include_term_hierarchy: None,
}
}
#[doc = "Get all related objects assigned with the specified term."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `term_guid`: The globally unique identifier for glossary term."]
pub fn get_entities_assigned_with_term(&self, term_guid: impl Into<String>) -> get_entities_assigned_with_term::RequestBuilder {
get_entities_assigned_with_term::RequestBuilder {
client: self.0.clone(),
term_guid: term_guid.into(),
limit: None,
offset: None,
sort: None,
}
}
#[doc = "Assign the given term to the provided list of related objects."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `term_guid`: The globally unique identifier for glossary term."]
#[doc = "* `related_object_ids`: An array of related object IDs to which the term has to be associated."]
pub fn assign_term_to_entities(
&self,
term_guid: impl Into<String>,
related_object_ids: Vec<models::AtlasRelatedObjectId>,
) -> assign_term_to_entities::RequestBuilder {
assign_term_to_entities::RequestBuilder {
client: self.0.clone(),
term_guid: term_guid.into(),
related_object_ids,
}
}
#[doc = "Delete the term assignment for the given list of related objects."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `term_guid`: The globally unique identifier for glossary term."]
#[doc = "* `related_object_ids`: An array of related object IDs from which the term has to be dissociated."]
pub fn remove_term_assignment_from_entities(
&self,
term_guid: impl Into<String>,
related_object_ids: Vec<models::AtlasRelatedObjectId>,
) -> remove_term_assignment_from_entities::RequestBuilder {
remove_term_assignment_from_entities::RequestBuilder {
client: self.0.clone(),
term_guid: term_guid.into(),
related_object_ids,
}
}
#[doc = "Delete the term assignment for the given list of related objects."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `term_guid`: The globally unique identifier for glossary term."]
#[doc = "* `related_object_ids`: An array of related object IDs from which the term has to be dissociated."]
pub fn delete_term_assignment_from_entities(
&self,
term_guid: impl Into<String>,
related_object_ids: Vec<models::AtlasRelatedObjectId>,
) -> delete_term_assignment_from_entities::RequestBuilder {
delete_term_assignment_from_entities::RequestBuilder {
client: self.0.clone(),
term_guid: term_guid.into(),
related_object_ids,
}
}
#[doc = "Get all related terms for a specific term by its GUID. Limit, offset, and sort parameters are currently not being enabled and won't work even they are passed."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `term_guid`: The globally unique identifier for glossary term."]
pub fn list_related_terms(&self, term_guid: impl Into<String>) -> list_related_terms::RequestBuilder {
list_related_terms::RequestBuilder {
client: self.0.clone(),
term_guid: term_guid.into(),
limit: None,
offset: None,
sort: None,
}
}
#[doc = "Get a specific Glossary by its GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_guid`: The globally unique identifier for glossary."]
pub fn get_glossary(&self, glossary_guid: impl Into<String>) -> get_glossary::RequestBuilder {
get_glossary::RequestBuilder {
client: self.0.clone(),
glossary_guid: glossary_guid.into(),
}
}
#[doc = "Update the given glossary."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_guid`: The globally unique identifier for glossary."]
#[doc = "* `updated_glossary`: The glossary definition to be updated."]
pub fn update_glossary(
&self,
glossary_guid: impl Into<String>,
updated_glossary: impl Into<models::AtlasGlossary>,
) -> update_glossary::RequestBuilder {
update_glossary::RequestBuilder {
client: self.0.clone(),
glossary_guid: glossary_guid.into(),
updated_glossary: updated_glossary.into(),
}
}
#[doc = "Delete a glossary."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_guid`: The globally unique identifier for glossary."]
pub fn delete_glossary(&self, glossary_guid: impl Into<String>) -> delete_glossary::RequestBuilder {
delete_glossary::RequestBuilder {
client: self.0.clone(),
glossary_guid: glossary_guid.into(),
}
}
#[doc = "Get the categories belonging to a specific glossary."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_guid`: The globally unique identifier for glossary."]
pub fn list_glossary_categories(&self, glossary_guid: impl Into<String>) -> list_glossary_categories::RequestBuilder {
list_glossary_categories::RequestBuilder {
client: self.0.clone(),
glossary_guid: glossary_guid.into(),
limit: None,
offset: None,
sort: None,
}
}
#[doc = "Get the category headers belonging to a specific glossary."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_guid`: The globally unique identifier for glossary."]
pub fn list_glossary_categories_headers(
&self,
glossary_guid: impl Into<String>,
) -> list_glossary_categories_headers::RequestBuilder {
list_glossary_categories_headers::RequestBuilder {
client: self.0.clone(),
glossary_guid: glossary_guid.into(),
limit: None,
offset: None,
sort: None,
}
}
#[doc = "Get a specific glossary with detailed information."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_guid`: The globally unique identifier for glossary."]
pub fn get_detailed_glossary(&self, glossary_guid: impl Into<String>) -> get_detailed_glossary::RequestBuilder {
get_detailed_glossary::RequestBuilder {
client: self.0.clone(),
glossary_guid: glossary_guid.into(),
include_term_hierarchy: None,
}
}
#[doc = "Update the glossary partially. Some properties such as qualifiedName are not allowed to be updated."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_guid`: The globally unique identifier for glossary."]
#[doc = "* `partial_updates`: A map containing keys as attribute names and values as corresponding attribute values."]
pub fn partial_update_glossary(
&self,
glossary_guid: impl Into<String>,
partial_updates: impl Into<serde_json::Value>,
) -> partial_update_glossary::RequestBuilder {
partial_update_glossary::RequestBuilder {
client: self.0.clone(),
glossary_guid: glossary_guid.into(),
partial_updates: partial_updates.into(),
include_term_hierarchy: None,
}
}
#[doc = "Get terms belonging to a specific glossary."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_guid`: The globally unique identifier for glossary."]
pub fn list_glossary_terms(&self, glossary_guid: impl Into<String>) -> list_glossary_terms::RequestBuilder {
list_glossary_terms::RequestBuilder {
client: self.0.clone(),
glossary_guid: glossary_guid.into(),
include_term_hierarchy: None,
limit: None,
offset: None,
sort: None,
}
}
#[doc = "Get term headers belonging to a specific glossary."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_guid`: The globally unique identifier for glossary."]
pub fn list_glossary_term_headers(&self, glossary_guid: impl Into<String>) -> list_glossary_term_headers::RequestBuilder {
list_glossary_term_headers::RequestBuilder {
client: self.0.clone(),
glossary_guid: glossary_guid.into(),
limit: None,
offset: None,
sort: None,
}
}
#[doc = "Import Glossary Terms from local csv file"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_guid`: The globally unique identifier for glossary."]
#[doc = "* `file`: The csv file to import glossary terms from."]
pub fn import_glossary_terms_via_csv(
&self,
glossary_guid: impl Into<String>,
file: impl Into<bytes::Bytes>,
) -> import_glossary_terms_via_csv::RequestBuilder {
import_glossary_terms_via_csv::RequestBuilder {
client: self.0.clone(),
glossary_guid: glossary_guid.into(),
file: file.into(),
include_term_hierarchy: None,
}
}
#[doc = "Import Glossary Terms from local csv file by glossaryName"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_name`: The name of the glossary."]
#[doc = "* `file`: The csv file to import glossary terms from."]
pub fn import_glossary_terms_via_csv_by_glossary_name(
&self,
glossary_name: impl Into<String>,
file: impl Into<bytes::Bytes>,
) -> import_glossary_terms_via_csv_by_glossary_name::RequestBuilder {
import_glossary_terms_via_csv_by_glossary_name::RequestBuilder {
client: self.0.clone(),
glossary_name: glossary_name.into(),
file: file.into(),
include_term_hierarchy: None,
}
}
#[doc = "Get the status of import csv operation"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `operation_guid`: The globally unique identifier for async operation/job."]
pub fn get_import_csv_operation_status(
&self,
operation_guid: impl Into<String>,
) -> get_import_csv_operation_status::RequestBuilder {
get_import_csv_operation_status::RequestBuilder {
client: self.0.clone(),
operation_guid: operation_guid.into(),
}
}
#[doc = "Export Glossary Terms as csv file"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_guid`: The globally unique identifier for glossary."]
#[doc = "* `term_guids`: An array of term guids."]
pub fn export_glossary_terms_as_csv(
&self,
glossary_guid: impl Into<String>,
term_guids: Vec<models::TermGuid>,
) -> export_glossary_terms_as_csv::RequestBuilder {
export_glossary_terms_as_csv::RequestBuilder {
client: self.0.clone(),
glossary_guid: glossary_guid.into(),
term_guids,
include_term_hierarchy: None,
}
}
#[doc = "Get terms by glossary name."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `glossary_name`: The name of the glossary."]
pub fn list_terms_by_glossary_name(&self, glossary_name: impl Into<String>) -> list_terms_by_glossary_name::RequestBuilder {
list_terms_by_glossary_name::RequestBuilder {
client: self.0.clone(),
glossary_name: glossary_name.into(),
limit: None,
offset: None,
include_term_hierarchy: None,
}
}
}
pub mod list_glossaries {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::AtlasGlossary>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::AtlasGlossary> = 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) limit: Option<i32>,
pub(crate) offset: Option<i32>,
pub(crate) sort: Option<String>,
pub(crate) ignore_terms_and_categories: Option<bool>,
}
impl RequestBuilder {
#[doc = "The page size - by default there is no paging."]
pub fn limit(mut self, limit: i32) -> Self {
self.limit = Some(limit);
self
}
#[doc = "The offset for pagination purpose."]
pub fn offset(mut self, offset: i32) -> Self {
self.offset = Some(offset);
self
}
#[doc = "The sort order, ASC (default) or DESC."]
pub fn sort(mut self, sort: impl Into<String>) -> Self {
self.sort = Some(sort.into());
self
}
#[doc = "Whether ignore terms and categories"]
pub fn ignore_terms_and_categories(mut self, ignore_terms_and_categories: bool) -> Self {
self.ignore_terms_and_categories = Some(ignore_terms_and_categories);
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!("{}/atlas/v2/glossary", 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()),
);
if let Some(limit) = &this.limit {
req.url_mut().query_pairs_mut().append_pair("limit", &limit.to_string());
}
if let Some(offset) = &this.offset {
req.url_mut().query_pairs_mut().append_pair("offset", &offset.to_string());
}
if let Some(sort) = &this.sort {
req.url_mut().query_pairs_mut().append_pair("sort", sort);
}
if let Some(ignore_terms_and_categories) = &this.ignore_terms_and_categories {
req.url_mut()
.query_pairs_mut()
.append_pair("ignoreTermsAndCategories", &ignore_terms_and_categories.to_string());
}
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<Vec<models::AtlasGlossary>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_glossary {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossary> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossary = 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) atlas_glossary: models::AtlasGlossary,
}
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!("{}/atlas/v2/glossary", 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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.atlas_glossary)?;
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::AtlasGlossary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_glossary_categories {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::AtlasGlossaryCategory>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::AtlasGlossaryCategory> = 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) glossary_category: Vec<models::AtlasGlossaryCategory>,
}
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!("{}/atlas/v2/glossary/categories", 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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.glossary_category)?;
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<Vec<models::AtlasGlossaryCategory>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_glossary_category {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossaryCategory> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossaryCategory = 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) glossary_category: models::AtlasGlossaryCategory,
}
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!("{}/atlas/v2/glossary/category", 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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.glossary_category)?;
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::AtlasGlossaryCategory>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_glossary_category {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossaryCategory> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossaryCategory = 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) category_guid: 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!(
"{}/atlas/v2/glossary/category/{}",
this.client.endpoint(),
&this.category_guid
))?;
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::AtlasGlossaryCategory>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_glossary_category {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossaryCategory> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossaryCategory = 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) category_guid: String,
pub(crate) glossary_category: models::AtlasGlossaryCategory,
}
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!(
"{}/atlas/v2/glossary/category/{}",
this.client.endpoint(),
&this.category_guid
))?;
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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.glossary_category)?;
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::AtlasGlossaryCategory>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_glossary_category {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) category_guid: 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!(
"{}/atlas/v2/glossary/category/{}",
this.client.endpoint(),
&this.category_guid
))?;
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?))
}
})
}
}
}
pub mod partial_update_glossary_category {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossaryCategory> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossaryCategory = 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) category_guid: String,
pub(crate) partial_updates: serde_json::Value,
}
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!(
"{}/atlas/v2/glossary/category/{}/partial",
this.client.endpoint(),
&this.category_guid
))?;
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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.partial_updates)?;
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::AtlasGlossaryCategory>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_related_categories {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<serde_json::Value> {
let bytes = self.0.into_body().collect().await?;
let body: serde_json::Value = 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) category_guid: String,
pub(crate) limit: Option<i32>,
pub(crate) offset: Option<i32>,
pub(crate) sort: Option<String>,
}
impl RequestBuilder {
#[doc = "The page size - by default there is no paging."]
pub fn limit(mut self, limit: i32) -> Self {
self.limit = Some(limit);
self
}
#[doc = "The offset for pagination purpose."]
pub fn offset(mut self, offset: i32) -> Self {
self.offset = Some(offset);
self
}
#[doc = "The sort order, ASC (default) or DESC."]
pub fn sort(mut self, sort: impl Into<String>) -> Self {
self.sort = Some(sort.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!(
"{}/atlas/v2/glossary/category/{}/related",
this.client.endpoint(),
&this.category_guid
))?;
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()),
);
if let Some(limit) = &this.limit {
req.url_mut().query_pairs_mut().append_pair("limit", &limit.to_string());
}
if let Some(offset) = &this.offset {
req.url_mut().query_pairs_mut().append_pair("offset", &offset.to_string());
}
if let Some(sort) = &this.sort {
req.url_mut().query_pairs_mut().append_pair("sort", sort);
}
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<serde_json::Value>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_category_terms {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::AtlasRelatedTermHeader>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::AtlasRelatedTermHeader> = 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) category_guid: String,
pub(crate) limit: Option<i32>,
pub(crate) offset: Option<i32>,
pub(crate) sort: Option<String>,
}
impl RequestBuilder {
#[doc = "The page size - by default there is no paging."]
pub fn limit(mut self, limit: i32) -> Self {
self.limit = Some(limit);
self
}
#[doc = "The offset for pagination purpose."]
pub fn offset(mut self, offset: i32) -> Self {
self.offset = Some(offset);
self
}
#[doc = "The sort order, ASC (default) or DESC."]
pub fn sort(mut self, sort: impl Into<String>) -> Self {
self.sort = Some(sort.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!(
"{}/atlas/v2/glossary/category/{}/terms",
this.client.endpoint(),
&this.category_guid
))?;
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()),
);
if let Some(limit) = &this.limit {
req.url_mut().query_pairs_mut().append_pair("limit", &limit.to_string());
}
if let Some(offset) = &this.offset {
req.url_mut().query_pairs_mut().append_pair("offset", &offset.to_string());
}
if let Some(sort) = &this.sort {
req.url_mut().query_pairs_mut().append_pair("sort", sort);
}
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<Vec<models::AtlasRelatedTermHeader>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_glossary_term {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossaryTerm> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossaryTerm = 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) glossary_term: models::AtlasGlossaryTerm,
pub(crate) include_term_hierarchy: Option<bool>,
}
impl RequestBuilder {
#[doc = "Whether include term hierarchy"]
pub fn include_term_hierarchy(mut self, include_term_hierarchy: bool) -> Self {
self.include_term_hierarchy = Some(include_term_hierarchy);
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!("{}/atlas/v2/glossary/term", 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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.glossary_term)?;
if let Some(include_term_hierarchy) = &this.include_term_hierarchy {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermHierarchy", &include_term_hierarchy.to_string());
}
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::AtlasGlossaryTerm>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_glossary_term {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossaryTerm> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossaryTerm = 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) term_guid: String,
pub(crate) include_term_hierarchy: Option<bool>,
pub(crate) exclude_relationship_types: Vec<String>,
}
impl RequestBuilder {
#[doc = "Whether include term hierarchy"]
pub fn include_term_hierarchy(mut self, include_term_hierarchy: bool) -> Self {
self.include_term_hierarchy = Some(include_term_hierarchy);
self
}
#[doc = "An array of relationship types which need to be excluded."]
pub fn exclude_relationship_types(mut self, exclude_relationship_types: Vec<String>) -> Self {
self.exclude_relationship_types = exclude_relationship_types;
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!("{}/atlas/v2/glossary/term/{}", this.client.endpoint(), &this.term_guid))?;
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()),
);
if let Some(include_term_hierarchy) = &this.include_term_hierarchy {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermHierarchy", &include_term_hierarchy.to_string());
}
let exclude_relationship_types = &this.exclude_relationship_types;
for value in &this.exclude_relationship_types {
req.url_mut()
.query_pairs_mut()
.append_pair("excludeRelationshipTypes", &value.to_string());
}
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::AtlasGlossaryTerm>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_glossary_term {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossaryTerm> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossaryTerm = 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) term_guid: String,
pub(crate) glossary_term: models::AtlasGlossaryTerm,
pub(crate) include_term_hierarchy: Option<bool>,
}
impl RequestBuilder {
#[doc = "Whether include term hierarchy"]
pub fn include_term_hierarchy(mut self, include_term_hierarchy: bool) -> Self {
self.include_term_hierarchy = Some(include_term_hierarchy);
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!("{}/atlas/v2/glossary/term/{}", this.client.endpoint(), &this.term_guid))?;
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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.glossary_term)?;
if let Some(include_term_hierarchy) = &this.include_term_hierarchy {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermHierarchy", &include_term_hierarchy.to_string());
}
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::AtlasGlossaryTerm>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_glossary_term {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) term_guid: 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!("{}/atlas/v2/glossary/term/{}", this.client.endpoint(), &this.term_guid))?;
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?))
}
})
}
}
}
pub mod partial_update_glossary_term {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossaryTerm> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossaryTerm = 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) term_guid: String,
pub(crate) partial_updates: serde_json::Value,
pub(crate) include_term_hierarchy: Option<bool>,
}
impl RequestBuilder {
#[doc = "Whether include term hierarchy"]
pub fn include_term_hierarchy(mut self, include_term_hierarchy: bool) -> Self {
self.include_term_hierarchy = Some(include_term_hierarchy);
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!(
"{}/atlas/v2/glossary/term/{}/partial",
this.client.endpoint(),
&this.term_guid
))?;
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()),
);
if let Some(include_term_hierarchy) = &this.include_term_hierarchy {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermHierarchy", &include_term_hierarchy.to_string());
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.partial_updates)?;
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::AtlasGlossaryTerm>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_glossary_terms {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::AtlasGlossaryTerm>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::AtlasGlossaryTerm> = 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) glossary_term: Vec<models::AtlasGlossaryTerm>,
pub(crate) include_term_hierarchy: Option<bool>,
}
impl RequestBuilder {
#[doc = "Whether include term hierarchy"]
pub fn include_term_hierarchy(mut self, include_term_hierarchy: bool) -> Self {
self.include_term_hierarchy = Some(include_term_hierarchy);
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!("{}/atlas/v2/glossary/terms", 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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.glossary_term)?;
if let Some(include_term_hierarchy) = &this.include_term_hierarchy {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermHierarchy", &include_term_hierarchy.to_string());
}
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<Vec<models::AtlasGlossaryTerm>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_entities_assigned_with_term {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::AtlasRelatedObjectId>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::AtlasRelatedObjectId> = 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) term_guid: String,
pub(crate) limit: Option<i32>,
pub(crate) offset: Option<i32>,
pub(crate) sort: Option<String>,
}
impl RequestBuilder {
#[doc = "The page size - by default there is no paging."]
pub fn limit(mut self, limit: i32) -> Self {
self.limit = Some(limit);
self
}
#[doc = "The offset for pagination purpose."]
pub fn offset(mut self, offset: i32) -> Self {
self.offset = Some(offset);
self
}
#[doc = "The sort order, ASC (default) or DESC."]
pub fn sort(mut self, sort: impl Into<String>) -> Self {
self.sort = Some(sort.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!(
"{}/atlas/v2/glossary/terms/{}/assignedEntities",
this.client.endpoint(),
&this.term_guid
))?;
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()),
);
if let Some(limit) = &this.limit {
req.url_mut().query_pairs_mut().append_pair("limit", &limit.to_string());
}
if let Some(offset) = &this.offset {
req.url_mut().query_pairs_mut().append_pair("offset", &offset.to_string());
}
if let Some(sort) = &this.sort {
req.url_mut().query_pairs_mut().append_pair("sort", sort);
}
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<Vec<models::AtlasRelatedObjectId>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod assign_term_to_entities {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) term_guid: String,
pub(crate) related_object_ids: Vec<models::AtlasRelatedObjectId>,
}
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!(
"{}/atlas/v2/glossary/terms/{}/assignedEntities",
this.client.endpoint(),
&this.term_guid
))?;
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.related_object_ids)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod remove_term_assignment_from_entities {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) term_guid: String,
pub(crate) related_object_ids: Vec<models::AtlasRelatedObjectId>,
}
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!(
"{}/atlas/v2/glossary/terms/{}/assignedEntities",
this.client.endpoint(),
&this.term_guid
))?;
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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.related_object_ids)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod delete_term_assignment_from_entities {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) term_guid: String,
pub(crate) related_object_ids: Vec<models::AtlasRelatedObjectId>,
}
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!(
"{}/atlas/v2/glossary/terms/{}/assignedEntities",
this.client.endpoint(),
&this.term_guid
))?;
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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.related_object_ids)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_related_terms {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<serde_json::Value> {
let bytes = self.0.into_body().collect().await?;
let body: serde_json::Value = 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) term_guid: String,
pub(crate) limit: Option<i32>,
pub(crate) offset: Option<i32>,
pub(crate) sort: Option<String>,
}
impl RequestBuilder {
#[doc = "The page size - by default there is no paging."]
pub fn limit(mut self, limit: i32) -> Self {
self.limit = Some(limit);
self
}
#[doc = "The offset for pagination purpose."]
pub fn offset(mut self, offset: i32) -> Self {
self.offset = Some(offset);
self
}
#[doc = "The sort order, ASC (default) or DESC."]
pub fn sort(mut self, sort: impl Into<String>) -> Self {
self.sort = Some(sort.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!(
"{}/atlas/v2/glossary/terms/{}/related",
this.client.endpoint(),
&this.term_guid
))?;
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()),
);
if let Some(limit) = &this.limit {
req.url_mut().query_pairs_mut().append_pair("limit", &limit.to_string());
}
if let Some(offset) = &this.offset {
req.url_mut().query_pairs_mut().append_pair("offset", &offset.to_string());
}
if let Some(sort) = &this.sort {
req.url_mut().query_pairs_mut().append_pair("sort", sort);
}
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<serde_json::Value>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_glossary {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossary> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossary = 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) glossary_guid: 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!("{}/atlas/v2/glossary/{}", this.client.endpoint(), &this.glossary_guid))?;
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::AtlasGlossary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_glossary {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossary> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossary = 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) glossary_guid: String,
pub(crate) updated_glossary: models::AtlasGlossary,
}
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!("{}/atlas/v2/glossary/{}", this.client.endpoint(), &this.glossary_guid))?;
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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.updated_glossary)?;
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::AtlasGlossary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_glossary {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) glossary_guid: 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!("{}/atlas/v2/glossary/{}", this.client.endpoint(), &this.glossary_guid))?;
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?))
}
})
}
}
}
pub mod list_glossary_categories {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::AtlasGlossaryCategory>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::AtlasGlossaryCategory> = 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) glossary_guid: String,
pub(crate) limit: Option<i32>,
pub(crate) offset: Option<i32>,
pub(crate) sort: Option<String>,
}
impl RequestBuilder {
#[doc = "The page size - by default there is no paging."]
pub fn limit(mut self, limit: i32) -> Self {
self.limit = Some(limit);
self
}
#[doc = "The offset for pagination purpose."]
pub fn offset(mut self, offset: i32) -> Self {
self.offset = Some(offset);
self
}
#[doc = "The sort order, ASC (default) or DESC."]
pub fn sort(mut self, sort: impl Into<String>) -> Self {
self.sort = Some(sort.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!(
"{}/atlas/v2/glossary/{}/categories",
this.client.endpoint(),
&this.glossary_guid
))?;
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()),
);
if let Some(limit) = &this.limit {
req.url_mut().query_pairs_mut().append_pair("limit", &limit.to_string());
}
if let Some(offset) = &this.offset {
req.url_mut().query_pairs_mut().append_pair("offset", &offset.to_string());
}
if let Some(sort) = &this.sort {
req.url_mut().query_pairs_mut().append_pair("sort", sort);
}
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<Vec<models::AtlasGlossaryCategory>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_glossary_categories_headers {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::AtlasRelatedCategoryHeader>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::AtlasRelatedCategoryHeader> = 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) glossary_guid: String,
pub(crate) limit: Option<i32>,
pub(crate) offset: Option<i32>,
pub(crate) sort: Option<String>,
}
impl RequestBuilder {
#[doc = "The page size - by default there is no paging."]
pub fn limit(mut self, limit: i32) -> Self {
self.limit = Some(limit);
self
}
#[doc = "The offset for pagination purpose."]
pub fn offset(mut self, offset: i32) -> Self {
self.offset = Some(offset);
self
}
#[doc = "The sort order, ASC (default) or DESC."]
pub fn sort(mut self, sort: impl Into<String>) -> Self {
self.sort = Some(sort.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!(
"{}/atlas/v2/glossary/{}/categories/headers",
this.client.endpoint(),
&this.glossary_guid
))?;
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()),
);
if let Some(limit) = &this.limit {
req.url_mut().query_pairs_mut().append_pair("limit", &limit.to_string());
}
if let Some(offset) = &this.offset {
req.url_mut().query_pairs_mut().append_pair("offset", &offset.to_string());
}
if let Some(sort) = &this.sort {
req.url_mut().query_pairs_mut().append_pair("sort", sort);
}
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<Vec<models::AtlasRelatedCategoryHeader>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_detailed_glossary {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossaryExtInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossaryExtInfo = 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) glossary_guid: String,
pub(crate) include_term_hierarchy: Option<bool>,
}
impl RequestBuilder {
#[doc = "Whether include term hierarchy"]
pub fn include_term_hierarchy(mut self, include_term_hierarchy: bool) -> Self {
self.include_term_hierarchy = Some(include_term_hierarchy);
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!(
"{}/atlas/v2/glossary/{}/detailed",
this.client.endpoint(),
&this.glossary_guid
))?;
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()),
);
if let Some(include_term_hierarchy) = &this.include_term_hierarchy {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermHierarchy", &include_term_hierarchy.to_string());
}
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::AtlasGlossaryExtInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod partial_update_glossary {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasGlossary> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasGlossary = 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) glossary_guid: String,
pub(crate) partial_updates: serde_json::Value,
pub(crate) include_term_hierarchy: Option<bool>,
}
impl RequestBuilder {
#[doc = "Whether include term hierarchy"]
pub fn include_term_hierarchy(mut self, include_term_hierarchy: bool) -> Self {
self.include_term_hierarchy = Some(include_term_hierarchy);
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!(
"{}/atlas/v2/glossary/{}/partial",
this.client.endpoint(),
&this.glossary_guid
))?;
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()),
);
if let Some(include_term_hierarchy) = &this.include_term_hierarchy {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermHierarchy", &include_term_hierarchy.to_string());
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.partial_updates)?;
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::AtlasGlossary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_glossary_terms {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::AtlasGlossaryTerm>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::AtlasGlossaryTerm> = 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) glossary_guid: String,
pub(crate) include_term_hierarchy: Option<bool>,
pub(crate) limit: Option<i32>,
pub(crate) offset: Option<i32>,
pub(crate) sort: Option<String>,
}
impl RequestBuilder {
#[doc = "Whether include term hierarchy"]
pub fn include_term_hierarchy(mut self, include_term_hierarchy: bool) -> Self {
self.include_term_hierarchy = Some(include_term_hierarchy);
self
}
#[doc = "The page size - by default there is no paging."]
pub fn limit(mut self, limit: i32) -> Self {
self.limit = Some(limit);
self
}
#[doc = "The offset for pagination purpose."]
pub fn offset(mut self, offset: i32) -> Self {
self.offset = Some(offset);
self
}
#[doc = "The sort order, ASC (default) or DESC."]
pub fn sort(mut self, sort: impl Into<String>) -> Self {
self.sort = Some(sort.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!(
"{}/atlas/v2/glossary/{}/terms",
this.client.endpoint(),
&this.glossary_guid
))?;
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()),
);
if let Some(include_term_hierarchy) = &this.include_term_hierarchy {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermHierarchy", &include_term_hierarchy.to_string());
}
if let Some(limit) = &this.limit {
req.url_mut().query_pairs_mut().append_pair("limit", &limit.to_string());
}
if let Some(offset) = &this.offset {
req.url_mut().query_pairs_mut().append_pair("offset", &offset.to_string());
}
if let Some(sort) = &this.sort {
req.url_mut().query_pairs_mut().append_pair("sort", sort);
}
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<Vec<models::AtlasGlossaryTerm>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_glossary_term_headers {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::AtlasRelatedTermHeader>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::AtlasRelatedTermHeader> = 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) glossary_guid: String,
pub(crate) limit: Option<i32>,
pub(crate) offset: Option<i32>,
pub(crate) sort: Option<String>,
}
impl RequestBuilder {
#[doc = "The page size - by default there is no paging."]
pub fn limit(mut self, limit: i32) -> Self {
self.limit = Some(limit);
self
}
#[doc = "The offset for pagination purpose."]
pub fn offset(mut self, offset: i32) -> Self {
self.offset = Some(offset);
self
}
#[doc = "The sort order, ASC (default) or DESC."]
pub fn sort(mut self, sort: impl Into<String>) -> Self {
self.sort = Some(sort.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!(
"{}/atlas/v2/glossary/{}/terms/headers",
this.client.endpoint(),
&this.glossary_guid
))?;
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()),
);
if let Some(limit) = &this.limit {
req.url_mut().query_pairs_mut().append_pair("limit", &limit.to_string());
}
if let Some(offset) = &this.offset {
req.url_mut().query_pairs_mut().append_pair("offset", &offset.to_string());
}
if let Some(sort) = &this.sort {
req.url_mut().query_pairs_mut().append_pair("sort", sort);
}
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<Vec<models::AtlasRelatedTermHeader>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod import_glossary_terms_via_csv {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ImportCsvOperation> {
let bytes = self.0.into_body().collect().await?;
let body: models::ImportCsvOperation = 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) glossary_guid: String,
pub(crate) file: bytes::Bytes,
pub(crate) include_term_hierarchy: Option<bool>,
}
impl RequestBuilder {
#[doc = "Whether include term hierarchy"]
pub fn include_term_hierarchy(mut self, include_term_hierarchy: bool) -> Self {
self.include_term_hierarchy = Some(include_term_hierarchy);
self
}
#[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!("{}/glossary/{}/terms/import", this.client.endpoint(), &this.glossary_guid))?;
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, "2022-03-01-preview");
if let Some(include_term_hierarchy) = &this.include_term_hierarchy {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermHierarchy", &include_term_hierarchy.to_string());
}
unimplemented!("form data not yet supported");
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::ImportCsvOperation>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod import_glossary_terms_via_csv_by_glossary_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ImportCsvOperation> {
let bytes = self.0.into_body().collect().await?;
let body: models::ImportCsvOperation = 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) glossary_name: String,
pub(crate) file: bytes::Bytes,
pub(crate) include_term_hierarchy: Option<bool>,
}
impl RequestBuilder {
#[doc = "Whether include term hierarchy"]
pub fn include_term_hierarchy(mut self, include_term_hierarchy: bool) -> Self {
self.include_term_hierarchy = Some(include_term_hierarchy);
self
}
#[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!(
"{}/glossary/name/{}/terms/import",
this.client.endpoint(),
&this.glossary_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, "2022-03-01-preview");
if let Some(include_term_hierarchy) = &this.include_term_hierarchy {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermHierarchy", &include_term_hierarchy.to_string());
}
unimplemented!("form data not yet supported");
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::ImportCsvOperation>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_import_csv_operation_status {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ImportCsvOperation> {
let bytes = self.0.into_body().collect().await?;
let body: models::ImportCsvOperation = 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) operation_guid: 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!(
"{}/glossary/terms/import/{}",
this.client.endpoint(),
&this.operation_guid
))?;
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, "2022-03-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::ImportCsvOperation>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod export_glossary_terms_as_csv {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<bytes::Bytes> {
let bytes = self.0.into_body().collect().await?;
let body = 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) glossary_guid: String,
pub(crate) term_guids: Vec<models::TermGuid>,
pub(crate) include_term_hierarchy: Option<bool>,
}
impl RequestBuilder {
#[doc = "Whether include term hierarchy"]
pub fn include_term_hierarchy(mut self, include_term_hierarchy: bool) -> Self {
self.include_term_hierarchy = Some(include_term_hierarchy);
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!("{}/glossary/{}/terms/export", this.client.endpoint(), &this.glossary_guid))?;
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, "2022-03-01-preview");
if let Some(include_term_hierarchy) = &this.include_term_hierarchy {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermHierarchy", &include_term_hierarchy.to_string());
}
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.term_guids)?;
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<bytes::Bytes>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_terms_by_glossary_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::AtlasGlossaryTerm>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::AtlasGlossaryTerm> = 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) glossary_name: String,
pub(crate) limit: Option<i32>,
pub(crate) offset: Option<i32>,
pub(crate) include_term_hierarchy: Option<bool>,
}
impl RequestBuilder {
#[doc = "The page size - by default there is no paging."]
pub fn limit(mut self, limit: i32) -> Self {
self.limit = Some(limit);
self
}
#[doc = "The offset for pagination purpose."]
pub fn offset(mut self, offset: i32) -> Self {
self.offset = Some(offset);
self
}
#[doc = "Whether include term hierarchy"]
pub fn include_term_hierarchy(mut self, include_term_hierarchy: bool) -> Self {
self.include_term_hierarchy = Some(include_term_hierarchy);
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!("{}/glossary/name/{}/terms", this.client.endpoint(), &this.glossary_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, "2022-03-01-preview");
if let Some(limit) = &this.limit {
req.url_mut().query_pairs_mut().append_pair("limit", &limit.to_string());
}
if let Some(offset) = &this.offset {
req.url_mut().query_pairs_mut().append_pair("offset", &offset.to_string());
}
if let Some(include_term_hierarchy) = &this.include_term_hierarchy {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermHierarchy", &include_term_hierarchy.to_string());
}
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<Vec<models::AtlasGlossaryTerm>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod discovery {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Gets data using search."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `search_request`: An object specifying the search criteria."]
pub fn query(&self, search_request: impl Into<models::SearchRequest>) -> query::RequestBuilder {
query::RequestBuilder {
client: self.0.clone(),
search_request: search_request.into(),
}
}
#[doc = "Get search suggestions by query criteria."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `suggest_request`: An object specifying the suggest criteria."]
pub fn suggest(&self, suggest_request: impl Into<models::SuggestRequest>) -> suggest::RequestBuilder {
suggest::RequestBuilder {
client: self.0.clone(),
suggest_request: suggest_request.into(),
}
}
#[doc = "Browse entities by path or entity type."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `browse_request`: An object specifying the browse criteria."]
pub fn browse(&self, browse_request: impl Into<models::BrowseRequest>) -> browse::RequestBuilder {
browse::RequestBuilder {
client: self.0.clone(),
browse_request: browse_request.into(),
}
}
#[doc = "Get auto complete options."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `auto_complete_request`: An object specifying the autocomplete criteria."]
pub fn auto_complete(&self, auto_complete_request: impl Into<models::AutoCompleteRequest>) -> auto_complete::RequestBuilder {
auto_complete::RequestBuilder {
client: self.0.clone(),
auto_complete_request: auto_complete_request.into(),
}
}
}
pub mod query {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SearchResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::SearchResult = 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) search_request: models::SearchRequest,
}
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!("{}/search/query", 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, "2022-03-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.search_request)?;
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::SearchResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod suggest {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SuggestResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::SuggestResult = 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) suggest_request: models::SuggestRequest,
}
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!("{}/search/suggest", 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, "2022-03-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.suggest_request)?;
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::SuggestResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod browse {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BrowseResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::BrowseResult = 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) browse_request: models::BrowseRequest,
}
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!("{}/browse", 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, "2022-03-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.browse_request)?;
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::BrowseResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod auto_complete {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AutoCompleteResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::AutoCompleteResult = 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) auto_complete_request: models::AutoCompleteRequest,
}
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!("{}/search/autocomplete", 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, "2022-03-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.auto_complete_request)?;
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::AutoCompleteResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod lineage {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get lineage info of the entity specified by GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
#[doc = "* `direction`: The direction of the lineage, which could be INPUT, OUTPUT or BOTH."]
pub fn get_lineage_graph(&self, guid: impl Into<String>, direction: impl Into<String>) -> get_lineage_graph::RequestBuilder {
get_lineage_graph::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
direction: direction.into(),
depth: None,
width: None,
include_parent: None,
get_derived_lineage: None,
}
}
#[doc = "Return immediate next page lineage info about entity with pagination"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
#[doc = "* `direction`: The direction of the lineage, which could be INPUT, OUTPUT or BOTH."]
pub fn next_page_lineage(&self, guid: impl Into<String>, direction: impl Into<String>) -> next_page_lineage::RequestBuilder {
next_page_lineage::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
direction: direction.into(),
get_derived_lineage: None,
offset: None,
limit: None,
}
}
#[doc = "Returns lineage info about entity.\n\nIn addition to the typeName path parameter, attribute key-value pair(s) can be provided in the following format\n\nattr:[attrName]=[attrValue]\n\nNOTE: The attrName and attrValue should be unique across entities, eg. qualifiedName"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `type_name`: The name of the type."]
#[doc = "* `direction`: The direction of the lineage, which could be INPUT, OUTPUT or BOTH."]
pub fn get_lineage_by_unique_attribute(
&self,
type_name: impl Into<String>,
direction: impl Into<String>,
) -> get_lineage_by_unique_attribute::RequestBuilder {
get_lineage_by_unique_attribute::RequestBuilder {
client: self.0.clone(),
type_name: type_name.into(),
direction: direction.into(),
depth: None,
width: None,
include_parent: None,
get_derived_lineage: None,
}
}
}
pub mod get_lineage_graph {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasLineageInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasLineageInfo = 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) guid: String,
pub(crate) direction: String,
pub(crate) depth: Option<i32>,
pub(crate) width: Option<i32>,
pub(crate) include_parent: Option<bool>,
pub(crate) get_derived_lineage: Option<bool>,
}
impl RequestBuilder {
#[doc = "The number of hops for lineage."]
pub fn depth(mut self, depth: i32) -> Self {
self.depth = Some(depth);
self
}
#[doc = "The number of max expanding width in lineage."]
pub fn width(mut self, width: i32) -> Self {
self.width = Some(width);
self
}
#[doc = "True to include the parent chain in the response."]
pub fn include_parent(mut self, include_parent: bool) -> Self {
self.include_parent = Some(include_parent);
self
}
#[doc = "True to include derived lineage in the response"]
pub fn get_derived_lineage(mut self, get_derived_lineage: bool) -> Self {
self.get_derived_lineage = Some(get_derived_lineage);
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!("{}/atlas/v2/lineage/{}", this.client.endpoint(), &this.guid))?;
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()),
);
if let Some(depth) = &this.depth {
req.url_mut().query_pairs_mut().append_pair("depth", &depth.to_string());
}
if let Some(width) = &this.width {
req.url_mut().query_pairs_mut().append_pair("width", &width.to_string());
}
let direction = &this.direction;
req.url_mut().query_pairs_mut().append_pair("direction", direction);
if let Some(include_parent) = &this.include_parent {
req.url_mut()
.query_pairs_mut()
.append_pair("includeParent", &include_parent.to_string());
}
if let Some(get_derived_lineage) = &this.get_derived_lineage {
req.url_mut()
.query_pairs_mut()
.append_pair("getDerivedLineage", &get_derived_lineage.to_string());
}
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::AtlasLineageInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod next_page_lineage {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasLineageInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasLineageInfo = 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) guid: String,
pub(crate) direction: String,
pub(crate) get_derived_lineage: Option<bool>,
pub(crate) offset: Option<i32>,
pub(crate) limit: Option<i32>,
}
impl RequestBuilder {
#[doc = "True to include derived lineage in the response"]
pub fn get_derived_lineage(mut self, get_derived_lineage: bool) -> Self {
self.get_derived_lineage = Some(get_derived_lineage);
self
}
#[doc = "The offset for pagination purpose."]
pub fn offset(mut self, offset: i32) -> Self {
self.offset = Some(offset);
self
}
#[doc = "The page size - by default there is no paging."]
pub fn limit(mut self, limit: i32) -> Self {
self.limit = Some(limit);
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!("{}/lineage/{}/next/", this.client.endpoint(), &this.guid))?;
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, "2022-03-01-preview");
let direction = &this.direction;
req.url_mut().query_pairs_mut().append_pair("direction", direction);
if let Some(get_derived_lineage) = &this.get_derived_lineage {
req.url_mut()
.query_pairs_mut()
.append_pair("getDerivedLineage", &get_derived_lineage.to_string());
}
if let Some(offset) = &this.offset {
req.url_mut().query_pairs_mut().append_pair("offset", &offset.to_string());
}
if let Some(limit) = &this.limit {
req.url_mut().query_pairs_mut().append_pair("limit", &limit.to_string());
}
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::AtlasLineageInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_lineage_by_unique_attribute {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasLineageInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasLineageInfo = 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) type_name: String,
pub(crate) direction: String,
pub(crate) depth: Option<i32>,
pub(crate) width: Option<i32>,
pub(crate) include_parent: Option<bool>,
pub(crate) get_derived_lineage: Option<bool>,
}
impl RequestBuilder {
#[doc = "The number of hops for lineage."]
pub fn depth(mut self, depth: i32) -> Self {
self.depth = Some(depth);
self
}
#[doc = "The number of max expanding width in lineage."]
pub fn width(mut self, width: i32) -> Self {
self.width = Some(width);
self
}
#[doc = "True to include the parent chain in the response."]
pub fn include_parent(mut self, include_parent: bool) -> Self {
self.include_parent = Some(include_parent);
self
}
#[doc = "True to include derived lineage in the response"]
pub fn get_derived_lineage(mut self, get_derived_lineage: bool) -> Self {
self.get_derived_lineage = Some(get_derived_lineage);
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!(
"{}/atlas/v2/lineage/uniqueAttribute/type/{}",
this.client.endpoint(),
&this.type_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()),
);
if let Some(depth) = &this.depth {
req.url_mut().query_pairs_mut().append_pair("depth", &depth.to_string());
}
if let Some(width) = &this.width {
req.url_mut().query_pairs_mut().append_pair("width", &width.to_string());
}
let direction = &this.direction;
req.url_mut().query_pairs_mut().append_pair("direction", direction);
if let Some(include_parent) = &this.include_parent {
req.url_mut()
.query_pairs_mut()
.append_pair("includeParent", &include_parent.to_string());
}
if let Some(get_derived_lineage) = &this.get_derived_lineage {
req.url_mut()
.query_pairs_mut()
.append_pair("getDerivedLineage", &get_derived_lineage.to_string());
}
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::AtlasLineageInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod relationship {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Create a new relationship between entities."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `relationship`: The AtlasRelationship object containing the information for the relationship to be created."]
pub fn create(&self, relationship: impl Into<models::AtlasRelationship>) -> create::RequestBuilder {
create::RequestBuilder {
client: self.0.clone(),
relationship: relationship.into(),
}
}
#[doc = "Update an existing relationship between entities."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `relationship`: The AtlasRelationship object containing the information for the relationship to be created."]
pub fn update(&self, relationship: impl Into<models::AtlasRelationship>) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
relationship: relationship.into(),
}
}
#[doc = "Get relationship information between entities by its GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the relationship."]
pub fn get(&self, guid: impl Into<String>) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
extended_info: None,
}
}
#[doc = "Delete a relationship between entities by its GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the relationship."]
pub fn delete(&self, guid: impl Into<String>) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
}
}
}
pub mod create {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasRelationship> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasRelationship = 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) relationship: models::AtlasRelationship,
}
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!("{}/atlas/v2/relationship", 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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.relationship)?;
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::AtlasRelationship>> {
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::AtlasRelationship> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasRelationship = 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) relationship: models::AtlasRelationship,
}
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!("{}/atlas/v2/relationship", this.client.endpoint(),))?;
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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.relationship)?;
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::AtlasRelationship>> {
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::AtlasRelationshipWithExtInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasRelationshipWithExtInfo = 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) guid: String,
pub(crate) extended_info: Option<bool>,
}
impl RequestBuilder {
#[doc = "Limits whether includes extended information."]
pub fn extended_info(mut self, extended_info: bool) -> Self {
self.extended_info = Some(extended_info);
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!("{}/atlas/v2/relationship/guid/{}", this.client.endpoint(), &this.guid))?;
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()),
);
if let Some(extended_info) = &this.extended_info {
req.url_mut()
.query_pairs_mut()
.append_pair("extendedInfo", &extended_info.to_string());
}
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::AtlasRelationshipWithExtInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) guid: 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!("{}/atlas/v2/relationship/guid/{}", this.client.endpoint(), &this.guid))?;
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?))
}
})
}
}
}
}
pub mod types {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get the businessMetadata definition for the given guid"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: businessMetadata guid"]
pub fn get_business_metadata_def_by_guid(&self, guid: impl Into<String>) -> get_business_metadata_def_by_guid::RequestBuilder {
get_business_metadata_def_by_guid::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
}
}
#[doc = "Get the businessMetadata definition by it's name (unique)"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name`: businessMetadata name"]
pub fn get_business_metadata_def_by_name(&self, name: impl Into<String>) -> get_business_metadata_def_by_name::RequestBuilder {
get_business_metadata_def_by_name::RequestBuilder {
client: self.0.clone(),
name: name.into(),
}
}
#[doc = "Get the classification definition for the given GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the classification."]
pub fn get_classification_def_by_guid(&self, guid: impl Into<String>) -> get_classification_def_by_guid::RequestBuilder {
get_classification_def_by_guid::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
}
}
#[doc = "Get the classification definition by its name (unique)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name`: The name of the classification."]
pub fn get_classification_def_by_name(&self, name: impl Into<String>) -> get_classification_def_by_name::RequestBuilder {
get_classification_def_by_name::RequestBuilder {
client: self.0.clone(),
name: name.into(),
}
}
#[doc = "Get the Entity definition for the given GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the entity."]
pub fn get_entity_definition_by_guid(&self, guid: impl Into<String>) -> get_entity_definition_by_guid::RequestBuilder {
get_entity_definition_by_guid::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
}
}
#[doc = "Get the entity definition by its name (unique)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name`: The name of the entity."]
pub fn get_entity_definition_by_name(&self, name: impl Into<String>) -> get_entity_definition_by_name::RequestBuilder {
get_entity_definition_by_name::RequestBuilder {
client: self.0.clone(),
name: name.into(),
}
}
#[doc = "Get the enum definition for the given GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the enum."]
pub fn get_enum_def_by_guid(&self, guid: impl Into<String>) -> get_enum_def_by_guid::RequestBuilder {
get_enum_def_by_guid::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
}
}
#[doc = "Get the enum definition by its name (unique)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name`: The name of the enum."]
pub fn get_enum_def_by_name(&self, name: impl Into<String>) -> get_enum_def_by_name::RequestBuilder {
get_enum_def_by_name::RequestBuilder {
client: self.0.clone(),
name: name.into(),
}
}
#[doc = "Get the relationship definition for the given GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the relationship."]
pub fn get_relationship_def_by_guid(&self, guid: impl Into<String>) -> get_relationship_def_by_guid::RequestBuilder {
get_relationship_def_by_guid::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
}
}
#[doc = "Get the relationship definition by its name (unique)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name`: The name of the relationship."]
pub fn get_relationship_def_by_name(&self, name: impl Into<String>) -> get_relationship_def_by_name::RequestBuilder {
get_relationship_def_by_name::RequestBuilder {
client: self.0.clone(),
name: name.into(),
}
}
#[doc = "Get the struct definition for the given GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the struct."]
pub fn get_struct_def_by_guid(&self, guid: impl Into<String>) -> get_struct_def_by_guid::RequestBuilder {
get_struct_def_by_guid::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
}
}
#[doc = "Get the struct definition by its name (unique)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name`: The name of the struct."]
pub fn get_struct_def_by_name(&self, name: impl Into<String>) -> get_struct_def_by_name::RequestBuilder {
get_struct_def_by_name::RequestBuilder {
client: self.0.clone(),
name: name.into(),
}
}
#[doc = "Get the type definition for the given GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the type."]
pub fn get_type_definition_by_guid(&self, guid: impl Into<String>) -> get_type_definition_by_guid::RequestBuilder {
get_type_definition_by_guid::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
}
}
#[doc = "Get the type definition by its name (unique)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name`: The name of the type."]
pub fn get_type_definition_by_name(&self, name: impl Into<String>) -> get_type_definition_by_name::RequestBuilder {
get_type_definition_by_name::RequestBuilder {
client: self.0.clone(),
name: name.into(),
}
}
#[doc = "Delete API for type identified by its name."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name`: The name of the type."]
pub fn delete_type_by_name(&self, name: impl Into<String>) -> delete_type_by_name::RequestBuilder {
delete_type_by_name::RequestBuilder {
client: self.0.clone(),
name: name.into(),
}
}
#[doc = "Get all type definitions in Atlas in bulk."]
pub fn get_all_type_definitions(&self) -> get_all_type_definitions::RequestBuilder {
get_all_type_definitions::RequestBuilder {
client: self.0.clone(),
include_term_template: None,
type_: None,
}
}
#[doc = "Create all atlas type definitions in bulk, only new definitions will be created.\nAny changes to the existing definitions will be discarded."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `types_def`: A composite wrapper object with corresponding lists of the type definition."]
pub fn create_type_definitions(&self, types_def: impl Into<models::AtlasTypesDef>) -> create_type_definitions::RequestBuilder {
create_type_definitions::RequestBuilder {
client: self.0.clone(),
types_def: types_def.into(),
}
}
#[doc = "Update all types in bulk, changes detected in the type definitions would be persisted."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `types_def`: A composite object that captures all type definition changes."]
pub fn update_atlas_type_definitions(
&self,
types_def: impl Into<models::AtlasTypesDef>,
) -> update_atlas_type_definitions::RequestBuilder {
update_atlas_type_definitions::RequestBuilder {
client: self.0.clone(),
types_def: types_def.into(),
}
}
#[doc = "Delete API for all types in bulk."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `types_def`: A composite object that captures all types to be deleted"]
pub fn delete_type_definitions(&self, types_def: impl Into<models::AtlasTypesDef>) -> delete_type_definitions::RequestBuilder {
delete_type_definitions::RequestBuilder {
client: self.0.clone(),
types_def: types_def.into(),
}
}
#[doc = "List all type definitions returned as a list of minimal information header."]
pub fn list_type_definition_headers(&self) -> list_type_definition_headers::RequestBuilder {
list_type_definition_headers::RequestBuilder {
client: self.0.clone(),
include_term_template: None,
type_: None,
}
}
#[doc = "Get the term template definition for the given GUID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `guid`: The globally unique identifier of the term template."]
pub fn get_term_template_def_by_guid(&self, guid: impl Into<String>) -> get_term_template_def_by_guid::RequestBuilder {
get_term_template_def_by_guid::RequestBuilder {
client: self.0.clone(),
guid: guid.into(),
}
}
#[doc = "Get the term template definition by its name (unique)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name`: The name of the term template."]
pub fn get_term_template_def_by_name(&self, name: impl Into<String>) -> get_term_template_def_by_name::RequestBuilder {
get_term_template_def_by_name::RequestBuilder {
client: self.0.clone(),
name: name.into(),
}
}
}
pub mod get_business_metadata_def_by_guid {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasBusinessMetadataDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasBusinessMetadataDef = 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) guid: 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!(
"{}/atlas/v2/types/businessmetadatadef/guid/{}",
this.client.endpoint(),
&this.guid
))?;
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::AtlasBusinessMetadataDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_business_metadata_def_by_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasBusinessMetadataDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasBusinessMetadataDef = 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) 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!(
"{}/atlas/v2/types/businessmetadatadef/name/{}",
this.client.endpoint(),
&this.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::AtlasBusinessMetadataDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_classification_def_by_guid {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasClassificationDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasClassificationDef = 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) guid: 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!(
"{}/atlas/v2/types/classificationdef/guid/{}",
this.client.endpoint(),
&this.guid
))?;
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::AtlasClassificationDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_classification_def_by_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasClassificationDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasClassificationDef = 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) 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!(
"{}/atlas/v2/types/classificationdef/name/{}",
this.client.endpoint(),
&this.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::AtlasClassificationDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_entity_definition_by_guid {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasEntityDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasEntityDef = 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) guid: 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!("{}/atlas/v2/types/entitydef/guid/{}", this.client.endpoint(), &this.guid))?;
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::AtlasEntityDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_entity_definition_by_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasEntityDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasEntityDef = 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) 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!("{}/atlas/v2/types/entitydef/name/{}", this.client.endpoint(), &this.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::AtlasEntityDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_enum_def_by_guid {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasEnumDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasEnumDef = 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) guid: 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!("{}/atlas/v2/types/enumdef/guid/{}", this.client.endpoint(), &this.guid))?;
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::AtlasEnumDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_enum_def_by_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasEnumDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasEnumDef = 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) 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!("{}/atlas/v2/types/enumdef/name/{}", this.client.endpoint(), &this.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::AtlasEnumDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_relationship_def_by_guid {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasRelationshipDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasRelationshipDef = 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) guid: 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!(
"{}/atlas/v2/types/relationshipdef/guid/{}",
this.client.endpoint(),
&this.guid
))?;
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::AtlasRelationshipDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_relationship_def_by_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasRelationshipDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasRelationshipDef = 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) 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!(
"{}/atlas/v2/types/relationshipdef/name/{}",
this.client.endpoint(),
&this.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::AtlasRelationshipDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_struct_def_by_guid {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasStructDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasStructDef = 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) guid: 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!("{}/atlas/v2/types/structdef/guid/{}", this.client.endpoint(), &this.guid))?;
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::AtlasStructDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_struct_def_by_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasStructDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasStructDef = 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) 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!("{}/atlas/v2/types/structdef/name/{}", this.client.endpoint(), &this.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::AtlasStructDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_type_definition_by_guid {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasTypeDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasTypeDef = 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) guid: 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!("{}/atlas/v2/types/typedef/guid/{}", this.client.endpoint(), &this.guid))?;
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::AtlasTypeDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_type_definition_by_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasTypeDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasTypeDef = 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) 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!("{}/atlas/v2/types/typedef/name/{}", this.client.endpoint(), &this.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::AtlasTypeDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_type_by_name {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) 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!("{}/atlas/v2/types/typedef/name/{}", this.client.endpoint(), &this.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?))
}
})
}
}
}
pub mod get_all_type_definitions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasTypesDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasTypesDef = 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) include_term_template: Option<bool>,
pub(crate) type_: Option<String>,
}
impl RequestBuilder {
#[doc = "Whether include termtemplatedef when return all typedefs.\nThis is always true when search filter type=term_template"]
pub fn include_term_template(mut self, include_term_template: bool) -> Self {
self.include_term_template = Some(include_term_template);
self
}
#[doc = "Typedef name as search filter when get typedefs."]
pub fn type_(mut self, type_: impl Into<String>) -> Self {
self.type_ = Some(type_.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!("{}/atlas/v2/types/typedefs", 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()),
);
if let Some(include_term_template) = &this.include_term_template {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermTemplate", &include_term_template.to_string());
}
if let Some(type_) = &this.type_ {
req.url_mut().query_pairs_mut().append_pair("type", type_);
}
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::AtlasTypesDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_type_definitions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasTypesDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasTypesDef = 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) types_def: models::AtlasTypesDef,
}
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!("{}/atlas/v2/types/typedefs", 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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.types_def)?;
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::AtlasTypesDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_atlas_type_definitions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AtlasTypesDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::AtlasTypesDef = 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) types_def: models::AtlasTypesDef,
}
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!("{}/atlas/v2/types/typedefs", this.client.endpoint(),))?;
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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.types_def)?;
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::AtlasTypesDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_type_definitions {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) types_def: models::AtlasTypesDef,
}
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!("{}/atlas/v2/types/typedefs", this.client.endpoint(),))?;
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.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.types_def)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_type_definition_headers {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::AtlasTypeDefHeader>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::AtlasTypeDefHeader> = 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) include_term_template: Option<bool>,
pub(crate) type_: Option<String>,
}
impl RequestBuilder {
#[doc = "Whether include termtemplatedef when return all typedefs.\nThis is always true when search filter type=term_template"]
pub fn include_term_template(mut self, include_term_template: bool) -> Self {
self.include_term_template = Some(include_term_template);
self
}
#[doc = "Typedef name as search filter when get typedefs."]
pub fn type_(mut self, type_: impl Into<String>) -> Self {
self.type_ = Some(type_.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!("{}/atlas/v2/types/typedefs/headers", 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()),
);
if let Some(include_term_template) = &this.include_term_template {
req.url_mut()
.query_pairs_mut()
.append_pair("includeTermTemplate", &include_term_template.to_string());
}
if let Some(type_) = &this.type_ {
req.url_mut().query_pairs_mut().append_pair("type", type_);
}
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<Vec<models::AtlasTypeDefHeader>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_term_template_def_by_guid {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TermTemplateDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::TermTemplateDef = 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) guid: 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!("{}/types/termtemplatedef/guid/{}", this.client.endpoint(), &this.guid))?;
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, "2022-03-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::TermTemplateDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_term_template_def_by_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TermTemplateDef> {
let bytes = self.0.into_body().collect().await?;
let body: models::TermTemplateDef = 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) 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!("{}/types/termtemplatedef/name/{}", this.client.endpoint(), &this.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, "2022-03-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::TermTemplateDef>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod collection {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Creates or updates an entity to a collection.\nExisting entity is matched using its unique guid if supplied or by its unique attributes eg: qualifiedName.\nMap and array of collections are not well supported. E.g., array<array<int>>, array<map<string, int>>."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `collection`: the collection unique name"]
#[doc = "* `entity`: Atlas entity with extended information."]
pub fn create_or_update(
&self,
collection: impl Into<String>,
entity: impl Into<models::AtlasEntityWithExtInfo>,
) -> create_or_update::RequestBuilder {
create_or_update::RequestBuilder {
client: self.0.clone(),
collection: collection.into(),
entity: entity.into(),
}
}
#[doc = "Creates or updates entities in bulk to a collection.\nExisting entity is matched using its unique guid if supplied or by its unique attributes eg: qualifiedName.\nMap and array of collections are not well supported. E.g., array<array<int>>, array<map<string, int>>."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `collection`: the collection unique name"]
#[doc = "* `entities`: Atlas entities with extended information."]
pub fn create_or_update_bulk(
&self,
collection: impl Into<String>,
entities: impl Into<models::AtlasEntitiesWithExtInfo>,
) -> create_or_update_bulk::RequestBuilder {
create_or_update_bulk::RequestBuilder {
client: self.0.clone(),
collection: collection.into(),
entities: entities.into(),
}
}
#[doc = "Move existing entities to the target collection."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `collection`: the collection unique name"]
#[doc = "* `move_entities_request`: Entity guids to be moved to target collection."]
pub fn move_entities_to_collection(
&self,
collection: impl Into<String>,
move_entities_request: impl Into<models::MoveEntitiesRequest>,
) -> move_entities_to_collection::RequestBuilder {
move_entities_to_collection::RequestBuilder {
client: self.0.clone(),
collection: collection.into(),
move_entities_request: move_entities_request.into(),
}
}
}
pub mod create_or_update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::EntityMutationResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::EntityMutationResponse = 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) collection: String,
pub(crate) entity: models::AtlasEntityWithExtInfo,
}
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!("{}/collections/{}/entity", this.client.endpoint(), &this.collection))?;
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, "2022-03-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.entity)?;
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::EntityMutationResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_bulk {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::EntityMutationResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::EntityMutationResponse = 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) collection: String,
pub(crate) entities: models::AtlasEntitiesWithExtInfo,
}
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!("{}/collections/{}/entity/bulk", this.client.endpoint(), &this.collection))?;
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, "2022-03-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.entities)?;
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::EntityMutationResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod move_entities_to_collection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::EntityMutationResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::EntityMutationResponse = 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) collection: String,
pub(crate) move_entities_request: models::MoveEntitiesRequest,
}
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!(
"{}/collections/{}/entity/moveHere",
this.client.endpoint(),
&this.collection
))?;
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, "2022-03-01-preview");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.move_entities_request)?;
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::EntityMutationResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}